import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
# サンプルデータの生成
np.random.seed(0)
X = np.random.rand(100, 1) * 10 # 入力データ
y = 2.5 * X + np.random.randn(100, 1) * 2 # 実際の値（ノイズ付き）
# 線形回帰モデルの学習
model = LinearRegression()
model.fit(X, y)
y_pred = model.predict(X) # 観測機械学習による予測値
# 実感誤差の計算
error = y - y_pred
mse = mean_squared_error(y, y_pred)
# プロットの作成
plt.figure(figsize=(12, 6))
# 実際のデータと予測データのプロット
plt.subplot(1, 2, 1)
plt.scatter(X, y, label='Actual Data')
plt.plot(X, y_pred, color='red', label='Predicted Data')
plt.xlabel('Input (X)')
plt.ylabel('Output (y)')
plt.title('Actual vs Predicted Data')
plt.legend()
plt.grid(True)
# 実感誤差のプロット
plt.subplot(1, 2, 2)
plt.scatter(X, error, label='Perceived Error', color='orange')
plt.axhline(y=0, color='black', linestyle='--')
plt.xlabel('Input (X)')
plt.ylabel('Error (y - y_pred)')
plt.title(f'Perceived Error (MSE: {mse:.2f})')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
# サンプルデータの生成
np.random.seed(0)
X = np.linspace(0, 10, 100)
# 真の関数 y = a * exp(b * X) + c
a, b, c = 2.5, 1.3, 0.5
y_true = a * np.exp(b * X) + c
# ノイズを加えたデータ
y = y_true + np.random.normal(scale=2, size=X.shape)
# 推定関数の定義
def model_func(X, a, b, c):
return a * np.exp(b * X) + c
# 最適化を用いて関数のパラメータを推定
popt, pcov = curve_fit(model_func, X, y, p0=(1, 1, 1))
a_est, b_est, c_est = popt
# 推定関数のプロット
y_est = model_func(X, *popt)
# プロットの作成
plt.figure(figsize=(10, 6))
# サンプルデータのプロット
plt.scatter(X, y, label='Noisy Data', color='blue', s=10)
# 真の関数のプロット
plt.plot(X, y_true, label='True Function', color='green')
# 推定関数のプロット
plt.plot(X, y_est, label=f'Estimated Function: a={a_est:.2f}, b={b_est:.2f}, c={c_est:.2f}', color='red')
# プロットの装飾
plt.xlabel('X')
plt.ylabel('y')
plt.title('Function Estimation and Optimization')
plt.legend()
plt.grid(True)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import BayesianRidge
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C
# サンプルデータの生成
np.random.seed(0)
X = np.linspace(0, 10, 100).reshape(-1, 1)
y_true = np.sin(X).ravel()
y = y_true + np.random.normal(scale=0.5, size=y_true.shape)
# ベイズ線形回帰モデル
bayesian_ridge = BayesianRidge()
bayesian_ridge.fit(X, y)
y_pred_bayes = bayesian_ridge.predict(X)
# ガウス過程回帰モデル
kernel = C(1.0, (1e-3, 1e3)) * RBF(1, (1e-2, 1e2))
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
gp.fit(X, y)
y_pred_gp, sigma = gp.predict(X, return_std=True)
# プロットの作成
plt.figure(figsize=(14, 7))
# サンプルデータのプロット
plt.scatter(X, y, label='Noisy Data', color='blue', s=10)
# 真の関数のプロット
plt.plot(X, y_true, label='True Function', color='green')
# ベイズ線形回帰モデルのプロット
plt.plot(X, y_pred_bayes, label='Bayesian Ridge Regression', color='red')
# ガウス過程回帰モデルのプロット
plt.plot(X, y_pred_gp, label='Gaussian Process Regression', color='orange')
plt.fill_between(X.ravel(), y_pred_gp - 1.96*sigma, y_pred_gp + 1.96*sigma, color='orange', alpha=0.2)
# プロットの装飾
plt.xlabel('X')
plt.ylabel('y')
plt.title('Bayesian Ridge Regression vs Gaussian Process Regression')
plt.legend()
plt.grid(True)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import multivariate_normal
# サンプルデータの生成
np.random.seed(42)
X = np.linspace(0, 10, 20)
y = 2.5 * X + np.random.normal(0, 1, X.shape[0])
# ベイズ線形回帰の事前分布
alpha = 2.0 # 事前分布の精度（分散の逆数）
beta = 25.0 # 観測ノイズの精度（分散の逆数）
# デザイン行列の作成
Phi = np.vstack([np.ones(X.shape), X]).T
# 事前分布のパラメータ
m0 = np.zeros(2) # 事前分布の平均
S0 = np.eye(2) / alpha # 事前分布の共分散行列
# 事後分布の計算
Sn_inv = np.linalg.inv(S0) + beta * Phi.T @ Phi
Sn = np.linalg.inv(Sn_inv)
mn = Sn @ (np.linalg.inv(S0) @ m0 + beta * Phi.T @ y)
# 予測分布の計算
X_new = np.linspace(0, 10, 100)
Phi_new = np.vstack([np.ones(X_new.shape), X_new]).T
y_pred = Phi_new @ mn
y_var = 1 / beta + np.sum(Phi_new @ Sn * Phi_new, axis=1)
y_std = np.sqrt(y_var)
# プロットの作成
plt.figure(figsize=(10, 6))
# 観測データのプロット
plt.scatter(X, y, color='blue', label='Observed data')
# 事前分布のプロット
w0, w1 = np.random.multivariate_normal(m0, S0, 5).T
for i in range(5):
plt.plot(X_new, w0[i] + w1[i] * X_new, color='green', alpha=0.3, label='Prior samples' if i == 0 else "")
# 事後分布のプロット
plt.plot(X_new, y_pred, color='red', label='Posterior mean')
plt.fill_between(X_new, y_pred - 1.96 * y_std, y_pred + 1.96 * y_std, color='red', alpha=0.2, label='95% confidence interval')
# プロットの装飾
plt.xlabel('Input (X)')
plt.ylabel('Output (y)')
plt.title('Bayesian Linear Regression')
plt.legend()
plt.grid(True)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C
# サンプルデータの生成
np.random.seed(42)
X = np.linspace(0, 10, 20).reshape(-1, 1)
y = np.sin(X).ravel() + np.random.normal(0, 0.1, X.shape[0])
# カーネル関数の設定
kernel = C(1.0, (1e-3, 1e3)) * RBF(1, (1e-2, 1e2))
# ガウス過程回帰モデルの作成
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10, alpha=0.1)
# モデルのフィッティング
gp.fit(X, y)
# 新しいデータポイントの作成
X_new = np.linspace(0, 10, 1000).reshape(-1, 1)
y_mean, y_std = gp.predict(X_new, return_std=True)
# プロットの作成
plt.figure(figsize=(14, 7))
# 観測データのプロット
plt.scatter(X, y, c='blue', label='Observed Data')
# ガウス過程の予測のプロット
plt.plot(X_new, y_mean, 'r-', label='Mean Prediction')
plt.fill_between(X_new.ravel(), y_mean - 1.96*y_std, y_mean + 1.96*y_std, alpha=0.2, color='orange', label='95% Confidence Interval')
# プロットの装飾
plt.xlabel('Input (X)')
plt.ylabel('Output (y)')
plt.title('Gaussian Process Regression with RBF Kernel')
plt.legend()
plt.grid(True)
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.special import expit
from statsmodels.genmod.generalized_linear_model import GLM
from statsmodels.genmod.families import Binomial
# Sample data generation
np.random.seed(42)
X = np.linspace(0, 10, 100)
y = (X > 5).astype(int) # Binary outcome
# Adding noise
X += np.random.normal(scale=0.5, size=X.shape)
y += np.random.binomial(1, 0.1, size=y.shape)
y = np.clip(y, 0, 1)
# Link function (logit)
def logit(x):
return expit(x)
# Parametric model using Generalized Linear Model (GLM)
X_ = np.column_stack((np.ones(X.shape[0]), X)) # Adding intercept
model = GLM(y, X_, family=Binomial())
results = model.fit()
# Predictive distribution
X_new = np.linspace(0, 10, 100)
X_new_ = np.column_stack((np.ones(X_new.shape[0]), X_new))
y_pred = results.predict(X_new_)
# Plotting
plt.figure(figsize=(10, 6))
# Observed data
plt.scatter(X, y, label='Observed data', color='blue')
# Link function
plt.plot(X_new, logit(results.params[0] + results.params[1] * X_new), label='Link function (logit)', color='red')
# Predictive distribution
plt.plot(X_new, y_pred, label='Predictive distribution', color='green')
# Plot decorations
plt.xlabel('Input (X)')
plt.ylabel('Output (y)')
plt.title('Parametric Modeling with Link Function and Predictive Distribution')
plt.legend()
plt.grid(True)
plt.show()
import numpy as np
from scipy.stats import beta
# トンプソン抽出のための初期化
n_arms = 2
alpha = np.ones(n_arms) # ベータ分布のα
beta_param = np.ones(n_arms) # ベータ分布のβ
n_trials = 1000 # 試行回数
def simulate_rewards():
"""各アームの報酬をシミュレートする"""
return np.random.rand(n_arms)
def select_arm():
"""トンプソン抽出に基づいてアームを選択する"""
samples = [beta.rvs(a, b) for a, b in zip(alpha, beta_param)]
return np.argmax(samples)
# シミュレーション
for _ in range(n_trials):
arm = select_arm()
rewards = simulate_rewards()
reward = rewards[arm]
# アームの報酬を更新
alpha[arm] += reward
beta_param[arm] += 1 - reward
# 結果
print("各アームの成功回数:", alpha)
print("各アームの失敗回数:", beta_param)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C
# サンプルデータと目的関数
def objective_function(x):
return np.sin(x)
# データポイントの生成
X_train = np.array([[1.0], [2.0], [3.0], [4.0]])
y_train = objective_function(X_train).ravel()
# ガウス過程のカーネル設定
kernel = C(1.0, (1e-3, 1e3)) * RBF(1.0, (1e-2, 1e2))
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
# モデルの学習
gp.fit(X_train, y_train)
# 推定ポイントの生成
X_test = np.linspace(0, 5, 1000).reshape(-1, 1)
y_pred, sigma = gp.predict(X_test, return_std=True)
# プロット
plt.figure()
plt.plot(X_train, y_train, 'r.', markersize=10, label='Observations')
plt.plot(X_test, y_pred, 'b-', label='Prediction')
plt.fill_between(X_test.ravel(), y_pred - 1.96 * sigma, y_pred + 1.96 * sigma, alpha=0.2, color='blue')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Gaussian Process Regression')
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from sklearn.gaussian_process import GaussianProcessRegressor
from sklearn.gaussian_process.kernels import RBF, ConstantKernel as C
# 目的関数
def objective_function(x):
return np.sin(x)
# サンプルデータの生成
X_train = np.array([[1.0], [2.0], [3.0], [4.0]])
y_train = objective_function(X_train).ravel()
# ガウス過程のカーネル設定
kernel = C(1.0, (1e-3, 1e3)) * RBF(1.0, (1e-2, 1e2))
gp = GaussianProcessRegressor(kernel=kernel, n_restarts_optimizer=10)
# モデルの学習
gp.fit(X_train, y_train)
# 推定ポイントの生成
X_test = np.linspace(0, 5, 1000).reshape(-1, 1)
y_pred, sigma = gp.predict(X_test, return_std=True)
# レベルセットの生成
level = 0.0 # レベルセットの値
level_set = (y_pred >= level).astype(int)
# プロット
plt.figure(figsize=(12, 6))
# 目的関数のプロット
plt.subplot(1, 2, 1)
plt.plot(X_train, y_train, 'r.', markersize=10, label='Observations')
plt.plot(X_test, y_pred, 'b-', label='GP Prediction')
plt.fill_between(X_test.ravel(), y_pred - 1.96 * sigma, y_pred + 1.96 * sigma, alpha=0.2, color='blue')
plt.axhline(y=level, color='k', linestyle='--', label='Level Set')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Gaussian Process Regression')
plt.legend()
# レベルセットのプロット
plt.subplot(1, 2, 2)
plt.plot(X_test, level_set, 'g-', label='Level Set')
plt.xlabel('x')
plt.ylabel('Level Set Indicator')
plt.title('Level Set Estimation')
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, classification_report
# データのロードと分割
data = load_iris()
X = data.data
y = data.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
# モデルの訓練
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)
# 予測
y_pred = model.predict(X_test)
# メトリックの計算
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='weighted')
recall = recall_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')
# 結果の表示
print(f'Accuracy: {accuracy:.2f}')
print(f'Avg. Precision: {precision:.2f}')
print(f'Avg. Recall: {recall:.2f}')
print(f'Avg. F-Measures: {f1:.2f}')
# 詳細な分類レポート
print('\nClassification Report:')
print
(classification_report(y_test, y_pred))
import matplotlib.pyplot as plt
from sklearn.model_selection import learning_curve
# 学習曲線の計算
train_sizes, train_scores, test_scores = learning_curve(
LogisticRegression(max_iter=200), X, y, cv=5, n_jobs=-1,
train_sizes=np.linspace(0.1, 1.0, 10)
)
# 平均と標準偏差の計算
train_mean = np.mean(train_scores, axis=1)
train_std = np.std(train_scores, axis=1)
test_mean = np.mean(test_scores, axis=1)
test_std = np.std(test_scores, axis=1)
# プロット
plt.figure()
plt.plot(train_sizes, train_mean, 'o-', color='r', label='Training score')
plt.plot(train_sizes, test_mean, 'o-', color='g', label='Cross-validation score')
# グラフの装飾
plt.title('Learning Curve')
plt.xlabel('Training examples')
plt.ylabel('Score')
plt.legend(loc='best')
plt.grid()
plt.show()
分類 (Classification)
回帰 (Regression)
クラスタリング (Clustering)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification, make_regression, make_blobs
from sklearn.linear_model import LogisticRegression, LinearRegression
from sklearn.cluster import KMeans
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, mean_squared_error
# 分類データの生成
X_class, y_class = make_classification(n_samples=200, n_features=2, n_classes=2, n_redundant=0, random_state=42)
# 回帰データの生成
X_reg, y_reg = make_regression(n_samples=100, n_features=1, noise=20, random_state=42)
# クラスタリングデータの生成
X_cluster, _ = make_blobs(n_samples=150, centers=3, n_features=2, random_state=42)
# 分類モデルの学習
X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class, y_class, test_size=0.3, random_state=42)
model_class = LogisticRegression()
model_class.fit(X_train_class, y_train_class)
y_pred_class = model_class.predict(X_test_class)
accuracy = accuracy_score(y_test_class, y_pred_class)
# 回帰モデルの学習
X_train_reg, X_test_reg, y_train_reg, y_test_reg = train_test_split(X_reg, y_reg, test_size=0.3, random_state=42)
model_reg = LinearRegression()
model_reg.fit(X_train_reg, y_train_reg)
y_pred_reg = model_reg.predict(X_test_reg)
mse = mean_squared_error(y_test_reg, y_pred_reg)
# クラスタリングモデルの学習
model_cluster = KMeans(n_clusters=3, random_state=42)
y_cluster = model_cluster.fit_predict(X_cluster)
# プロット
fig, axes = plt.subplots(1, 3, figsize=(18, 6))
# 分類プロット
axes[0].scatter(X_class[:, 0], X_class[:, 1], c=y_class, cmap='bwr', edgecolor='k', s=50)
axes[0].set_title(f'Classification (Accuracy: {accuracy:.2f})')
axes[0].set_xlabel('Feature 1')
axes[0].set_ylabel('Feature 2')
# 回帰プロット
axes[1].scatter(X_reg, y_reg, color='blue', edgecolor='k', s=50)
axes[1].plot(X_reg, model_reg.predict(X_reg), color='red', linewidth=2)
axes[1].set_title(f'Regression (MSE: {mse:.2f})')
axes[1].set_xlabel('Feature')
axes[1].set_ylabel('Target')
# クラスタリングプロット
axes[2].scatter(X_cluster[:, 0], X_cluster[:, 1], c=y_cluster, cmap='viridis', edgecolor='k', s=50)
axes[2].set_title('Clustering')
axes[2].set_xlabel('Feature 1')
axes[2].set_ylabel('Feature 2')
plt.tight_layout()
plt.show()
次元削減 (Dimensionality Reduction)
教師あり学習 (Supervised Learning)
教師なし学習 (Unsupervised Learning)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification, make_blobs
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.cluster import KMeans
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
# データ生成
X_class, y_class = make_classification(n_samples=200, n_features=5, n_classes=2, n_redundant=0, random_state=42)
X_blob, _ = make_blobs(n_samples=200, centers=3, n_features=5, random_state=42)
# 次元削減 (PCA)
pca = PCA(n_components=2)
X_class_pca = pca.fit_transform(X_class)
X_blob_pca = pca.transform(X_blob)
# 教師あり学習 (分類)
X_train_class, X_test_class, y_train_class, y_test_class = train_test_split(X_class_pca, y_class, test_size=0.3, random_state=42)
model_class = LogisticRegression()
model_class.fit(X_train_class, y_train_class)
y_pred_class = model_class.predict(X_test_class)
accuracy = accuracy_score(y_test_class, y_pred_class)
# 教師なし学習 (クラスタリング)
model_cluster = KMeans(n_clusters=3, random_state=42)
y_blob_cluster = model_cluster.fit_predict(X_blob_pca)
# プロット
fig, axes = plt.subplots(1, 3, figsize=(18, 6))
# 次元削減後のデータプロット
axes[0].scatter(X_class_pca[:, 0], X_class_pca[:, 1], c=y_class, cmap='bwr', edgecolor='k', s=50)
axes[0].set_title('PCA - Classification')
axes[0].set_xlabel('Principal Component 1')
axes[0].set_ylabel('Principal Component 2')
# 教師あり学習の結果プロット
axes[1].scatter(X_class_pca[:, 0], X_class_pca[:, 1], c=y_class, cmap='bwr', edgecolor='k', s=50)
axes[1].set_title(f'Classification (Accuracy: {accuracy:.2f})')
axes[1].set_xlabel('Principal Component 1')
axes[1].set_ylabel('Principal Component 2')
# 教師なし学習の結果プロット
axes[2].scatter(X_blob_pca[:, 0], X_blob_pca[:, 1], c=y_blob_cluster, cmap='viridis', edgecolor='k', s=50)
axes[2].set_title('Clustering (KMeans)')
axes[2].set_xlabel('Principal Component 1')
axes[2].set_ylabel('Principal Component 2')
plt.tight_layout()
plt.show()
強化学習 (Reinforcement Learning)
import numpy as np
import matplotlib.pyplot as plt
# 環境設定
n_states = 5
n_actions = 2
n_episodes = 1000
alpha = 0.1 # 学習率
gamma = 0.9 # 割引率
epsilon = 0.1 # 探索率
# Qテーブルの初期化
Q = np.zeros((n_states, n_actions))
def select_action(state):
if np.random.rand() < epsilon:
return np.random.randint(n_actions) # ランダムなアクション
else:
return np.argmax(Q[state]) # 最大のQ値を持つアクション
# 学習
for episode in range(n_episodes):
state = np.random.randint(n_states)
done = False
while not done:
action = select_action(state)
next_state = (state + action) % n_states # 状態遷移
reward = 1 if next_state == n_states - 1 else 0 # 報酬設定
Q[state, action] += alpha * (reward + gamma * np.max(Q[next_state]) - Q[state, action])
state = next_state
if state == n_states - 1:
done = True
# Qテーブルのプロット
plt.imshow(Q, cmap='hot', interpolation='nearest')
plt.colorbar()
plt.title('Q-Table')
plt.xlabel('Actions')
plt.ylabel('States')
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 行列の定義
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
# 行列乗算
C = np.dot(A, B)
# 特異値分解 (SVD)
U, S, Vt = np.linalg.svd(A)
S_matrix = np.zeros_like(A, dtype=float)
np.fill_diagonal(S_matrix, S)
# 固有値と固有ベクトル
eigenvalues, eigenvectors = np.linalg.eig(A)
# 結果の表示
print("Matrix A:")
print(A)
print("\nMatrix B:")
print(B)
print("\nMatrix A multiplied by B:")
print(C)
print("\nSVD of Matrix A:")
print("U:")
print(U)
print("S:")
print(S)
print("Vt:")
print(Vt)
print("\nEigenvalues of Matrix A:")
print(eigenvalues)
print("Eigenvectors of Matrix A:")
print(eigenvectors)
# 可視化
plt.figure(figsize=(12, 6))
# 行列のヒートマップ
plt.subplot(1, 2, 1)
plt.imshow(A, cmap='viridis', interpolation='none')
plt.title('Matrix A')
plt.colorbar()
plt.subplot(1, 2, 2)
plt.plot(eigenvalues, 'o', label='Eigenvalues')
plt.title('Eigenvalues of Matrix A')
plt.xlabel('Index')
plt.ylabel('Value')
plt.grid(True)
plt.legend()
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sympy import symbols, Eq, solve
# Define the problem parameters
total_birds = 10
total_legs = 28
# Create the data for regression
x = np.arange(11).reshape(-1, 1) # Cranes from 0 to 10
y = 2 * (10 - x) + 4 * x # Total legs for each number of cranes
# Train the linear regression model
model = LinearRegression()
model.fit(x, y)
# Predict values for plotting the regression line
x_range = np.linspace(0, 10, 100).reshape(-1, 1)
y_pred = model.predict(x_range)
# Solve the equations for the exact solution
x_sym, y_sym = symbols('x y')
eq1 = Eq(x_sym + y_sym, total_birds)
eq2 = Eq(2*x_sym + 4*y_sym, total_legs)
solution = solve((eq1, eq2), (x_sym, y_sym))
cranes = solution[x_sym]
turtles = solution[y_sym]
# Create data for plotting
x_values = np.arange(0, total_birds + 1)
y_values = total_birds - x_values
legs_values = 2 * x_values + 4 * y_values
# Plotting
plt.figure(figsize=(10, 6))
# Plot the total number of legs vs. cranes
plt.plot(x_values, legs_values, 'o', label='Legs Count', color='blue')
# Plot the linear regression line
plt.plot(x_range, y_pred, color='red', linestyle='--', label='Regression Line')
# Highlight the solution point
plt.plot(cranes, 2*cranes + 4*turtles, 'ro', label='Solution Point')
# Labels and title
plt.xlabel('Number of Cranes')
plt.ylabel('Total Number of Legs')
plt.title('Cranes and Turtles Problem with Linear Regression')
plt.legend()
plt.grid(True)
plt.show()
print(f"Number of Cranes: {cranes}")
print(f"Number of Turtles: {turtles}")
import numpy as np
import matplotlib.pyplot as plt
# Define the vector
v = np.array([1, -2, 3, -4, 5])
# Calculate norms
l1_norm = np.sum(np.abs(v))
l2_norm = np.sqrt(np.sum(v**2))
l_inf_norm = np.max(np.abs(v))
# Print the norms
print(f"L1 Norm: {l1_norm}")
print(f"L2 Norm: {l2_norm}")
print(f"L∞ Norm: {l_inf_norm}")
# Plot the vector and norms
plt.figure(figsize=(10, 6))
plt.bar(range(len(v)), v, color='blue', alpha=0.7, label='Vector v')
plt.axhline(y=l1_norm, color='r', linestyle='--', label=f'L1 Norm: {l1_norm}')
plt.axhline(y=l2_norm, color='g', linestyle='--', label=f'L2 Norm: {l2_norm}')
plt.axhline(y=l_inf_norm, color='orange', linestyle='--', label=f'L∞ Norm: {l_inf_norm}')
plt.xlabel('Index')
plt.ylabel('Value')
plt.title('Vector v and Norms Plot')
plt.legend()
plt.grid(True)
plt.show()
import numpy as np
import scipy.linalg as linalg
# Define the matrix
A = np.array([[4, 2], [3, 1]])
# LU Decomposition
P, L, U = linalg.lu(A)
print("LU Decomposition:")
print("P (Permutation Matrix):")
print(P)
print("L (Lower Triangular Matrix):")
print(L)
print("U (Upper Triangular Matrix):")
print(U)
# Eigenvalues and Eigenvectors
eigenvalues, eigenvectors = np.linalg.eig(A)
print("\nEigenvalues:")
print(eigenvalues)
print("Eigenvectors:")
print(eigenvectors)
# Singular Value Decomposition (SVD)
U_svd, S, Vt = np.linalg.svd(A)
print("\nSingular Value Decomposition:")
print("U (Left Singular Vectors):")
print(U_svd)
print("S (Singular Values):")
print(S)
print("V^T (Right Singular Vectors Transposed):")
print(Vt)
import numpy as np
import matplotlib.pyplot as plt
# Define a 2D point
point = np.array([1, 2])
# Define the linear transformation matrix A and translation vector b
A = np.array([[2, 0], [0, 1]])
b = np.array([1, -1])
# Perform affine transformation
transformed_point = A @ point + b
print("Original Point:", point)
print("Transformed Point:", transformed_point)
# Plot
plt.figure(figsize=(6, 6))
plt.plot(*point, 'ro', label='Original Point')
plt.plot(*transformed_point, 'bo', label='Transformed Point')
plt.axhline(0, color='black',linewidth=0.5)
plt.axvline(0, color='black',linewidth=0.5)
plt.grid(True)
plt.title('Affine Transformation')
plt.legend()
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
from sklearn.decomposition import PCA
import numpy as np
import matplotlib.pyplot as plt
# Generate sample data
np.random.seed(0)
data = np.random.randn(100, 3) # 100 points in 3D
# Apply PCA
pca = PCA(n_components=2) # Project to 2D
projected_data = pca.fit_transform(data)
print("Original Data Shape:", data.shape)
print("Projected Data Shape:", projected_data.shape)
# Plot the original and projected data
plt.figure(figsize=(12, 6))
# Plot original data
ax = plt.subplot(1, 2, 1, projection='3d')
ax.scatter(data[:, 0], data[:, 1], data[:, 2])
ax.set_title('Original Data')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
# Plot projected data
plt.subplot(1, 2, 2)
plt.scatter(projected_data[:, 0], projected_data[:, 1])
plt.title('Projected Data (2D)')
plt.xlabel('PC1')
plt.ylabel('PC2')
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 二次関数の定義とその勾配
def f(x):
return x**2 + 2*x + 1
def df(x):
return 2*x + 2
# 勾配降下法のパラメータ
learning_rate = 0.1
n_iterations = 100
x_init = 10 # 初期値
# 勾配降下法の実行
x = x_init
x_history = [x]
for _ in range(n_iterations):
grad = df(x)
x = x - learning_rate * grad
x_history.append(x)
# 結果の表示
x_values = np.linspace(-15, 15, 400)
y_values = f(x_values)
plt.figure(figsize=(8, 6))
plt.plot(x_values, y_values, label='$f(x) = x^2 + 2x + 1$', color='blue')
plt.scatter(x_history, [f(x) for x in x_history], color='red', label='Gradient Descent Steps')
plt.title('Gradient Descent Optimization')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True)
plt.show()
print(f"最小値に近いxの値: {x}")
import numpy as np
import matplotlib.pyplot as plt
# 二次関数の定義とその勾配
def f(x):
return x**2 + 2*x + 1
def df(x):
return 2*x + 2
# SGDのパラメータ
learning_rate = 0.1
n_iterations = 100
x_init = 10 # 初期値
# SGDの実行
x = x_init
x_history = [x]
for _ in range(n_iterations):
grad = df(x) # ミニバッチを考慮せず全データでの勾配
x = x - learning_rate * grad
x_history.append(x)
# 結果の表示
x_values = np.linspace(-15, 15, 400)
y_values = f(x_values)
plt.figure(figsize=(8, 6))
plt.plot(x_values, y_values, label='$f(x) = x^2 + 2x + 1$', color='blue')
plt.scatter(x_history, [f(x) for x in x_history], color='red', label='SGD Steps')
plt.title('Stochastic Gradient Descent Optimization')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True)
plt.show()
print(f"最小値に近いxの値: {x}")
import numpy as np
import matplotlib.pyplot as plt
# 二次関数の定義とその勾配
def f(x):
return x**2 + 2*x + 1
def df(x):
return 2*x + 2
# Adamのパラメータ
learning_rate = 0.01
beta1 = 0.9
beta2 = 0.999
epsilon = 1e-8
n_iterations = 100
x_init = 10 # 初期値
# Adamの実行
x = x_init
m = 0
v = 0
m_hat = 0
v_hat = 0
t = 0
x_history = [x]
for _ in range(n_iterations):
t += 1
grad = df(x)
m = beta1 * m + (1 - beta1) * grad
v = beta2 * v + (1 - beta2) * (grad ** 2)
m_hat = m / (1 - beta1 ** t)
v_hat = v / (1 - beta2 ** t)
x = x - learning_rate * m_hat / (np.sqrt(v_hat) + epsilon)
x_history.append(x)
# 結果の表示
x_values = np.linspace(-15, 15, 400)
y_values = f(x_values)
plt.figure(figsize=(8, 6))
plt.plot(x_values, y_values, label='$f(x) = x^2 + 2x + 1$', color='blue')
plt.scatter(x_history, [f(x) for x in x_history], color='red', label='Adam Steps')
plt.title('Adam Optimization')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True)
plt.show()
print(f"最小値に近いxの値: {x}")
import numpy as np
import matplotlib.pyplot as plt
# 二次関数の定義とその勾配とヘッセ行列
def f(x):
return x**2 + 2*x + 1
def df(x):
return 2*x + 2
def d2f(x):
return 2 # 二階微分（定数）
# ニュートン法のパラメータ
x_init = 10 # 初期値
n_iterations = 10
# ニュートン法の実行
x = x_init
x_history = [x]
for _ in range(n_iterations):
grad = df(x)
hessian = d2f(x)
x = x - grad / hessian
x_history.append(x)
# 結果の表示
x_values = np.linspace(-15, 15, 400)
y_values = f(x_values)
plt.figure(figsize=(8, 6))
plt.plot(x_values, y_values, label='$f(x) = x^2 + 2x + 1$', color='blue')
plt.scatter(x_history, [f(x) for x in x_history], color='red', label='Newton Steps')
plt.title('Newton\'s Method Optimization')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True)
plt.show()
print(f"最小値に近いxの値: {x}")
import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, roc_curve, auc
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
# データの生成
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
# モデルの訓練
model = LogisticRegression()
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
y_prob = model.predict_proba(X_test)[:, 1] # 陽性クラスの確率
# 評価指標の計算
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)
# 評価指標をリストにまとめる
scores = [accuracy, precision, recall, f1]
labels = ['Accuracy', 'Precision', 'Recall', 'F1 Score']
# バーグラフのプロット
plt.figure(figsize=(12, 5))
# バーグラフ
plt.subplot(1, 2, 1)
bars = plt.bar(labels, scores, color=['blue', 'orange', 'green', 'red'])
plt.ylim(0, 1) # スコアは0から1の範囲
plt.xlabel('Evaluation Metrics')
plt.ylabel('Score')
plt.title('Classification Model Evaluation Metrics')
# 各バーに値を表示
for bar in bars:
yval = bar.get_height()
plt.text(bar.get_x() + bar.get_width()/2, yval + 0.02, round(yval, 2), ha='center', va='bottom')
# ROC曲線とAUCの計算
fpr, tpr, _ = roc_curve(y_test, y_prob)
roc_auc = auc(fpr, tpr)
# ROC曲線のプロット
plt.subplot(1, 2, 2)
plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC)')
plt.legend(loc='lower right')
# グラフの表示
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
# サンプルデータの生成
X, y = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)
# k-meansクラスタリングモデルの作成
kmeans = KMeans(n_clusters=4) # クラスタ数は4に設定
kmeans.fit(X)
# クラスタの中心を取得
centers = kmeans.cluster_centers_
# 各データポイントのクラスタラベルを取得
labels = kmeans.labels_
# クラスタリング結果のプロット
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.scatter(centers[:, 0], centers[:, 1], s=300, c='red', marker='X') # クラスタ中心
plt.title("k-means Clustering")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 凸関数：絶対値関数 (微分不可能な点がある)
def f(x):
return np.abs(x)
# 劣勾配の計算 (x = 0 では複数の劣勾配が存在)
def subgradient(x):
if x > 0:
return 1
elif x < 0:
return -1
else:
return np.random.choice([-1, 1])
# 劣勾配法の実装
def subgradient_descent(initial_x, learning_rate=0.1, iterations=100):
x = initial_x
trajectory = [x]
for i in range(iterations):
grad = subgradient(x)
x = x - learning_rate * grad
trajectory.append(x)
return trajectory
# 初期値とパラメータ設定
initial_x = 2.0
learning_rate = 0.1
iterations = 50
# 劣勾配法の適用
trajectory = subgradient_descent(initial_x, learning_rate, iterations)
# 結果のプロット
x_vals = np.linspace(-3, 3, 400)
y_vals = f(x_vals)
plt.plot(x_vals, y_vals, label='f(x) = |x|')
plt.plot(trajectory, [f(x) for x in trajectory], 'ro-', label='Subgradient Descent')
plt.title('Subgradient Descent on f(x) = |x|')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 凸関数: f(x) = x^2
def f(x):
return x**2
# 1階微分 (勾配)
def gradient(x):
return 2 * x
# 2階微分 (ヘッセ行列)
def hessian(x):
return 2
# ニュートン法の実装
def newton_method(initial_x, iterations=10):
x = initial_x
trajectory = [x]
for i in range(iterations):
grad = gradient(x)
hess = hessian(x)
x = x - grad / hess # Newton法の更新ステップ
trajectory.append(x)
return trajectory
# 初期値とパラメータ設定
initial_x = 5.0
iterations = 10
# ニュートン法の適用
trajectory = newton_method(initial_x, iterations)
# 結果のプロット
x_vals = np.linspace(-6, 6, 400)
y_vals = f(x_vals)
plt.plot(x_vals, y_vals, label='f(x) = x^2')
plt.plot(trajectory, [f(x) for x in trajectory], 'ro-', label='Newton\'s Method')
plt.title('Newton\'s Method on f(x) = x^2')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.show()
import numpy as np
# 母集団データの生成
np.random.seed(0)
population = np.random.normal(loc=50, scale=10, size=10000) # 母平均50, 母標準偏差10の母集団
# サンプル抽出
sample = np.random.choice(population, size=100, replace=False)
# 統計量の計算
sample_mean = np.mean(sample)
sample_var = np.var(sample, ddof=1) # 標本分散（不偏分散）
# 母数との比較
population_mean = np.mean(population)
population_var = np.var(population)
print(f"母平均: {population_mean:.2f}, 標本平均: {sample_mean:.2f}")
print(f"母分散: {population_var:.2f}, 標本分散: {sample_var:.2f}")
import numpy as np
import matplotlib.pyplot as plt
# 二次関数 (例として f(x) = (x-3)^2 + 2)
def f(x):
return (x - 3)**2 + 2
# 関数の勾配
def gradient(x):
return 2 * (x - 3)
# 勾配降下法
def gradient_descent(initial_x, learning_rate=0.1, iterations=20):
x = initial_x
trajectory = [x]
for i in range(iterations):
grad = gradient(x)
x = x - learning_rate * grad # 勾配に沿った更新
trajectory.append(x)
return trajectory
# 初期値とパラメータ設定
initial_x = 0.0
learning_rate = 0.1
iterations = 20
# 勾配降下法の適用
trajectory = gradient_descent(initial_x, learning_rate, iterations)
# 結果のプロット
x_vals = np.linspace(-5, 10, 400)
y_vals = f(x_vals)
plt.plot(x_vals, y_vals, label='f(x) = (x-3)^2 + 2')
plt.plot(trajectory, [f(x) for x in trajectory], 'ro-', label='Gradient Descent')
plt.title('Gradient Descent on f(x)')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 仮想の訓練データセット
X = np.array([1, 2, 3, 4, 5])
y = np.array([1, 2, 3, 4, 5])
# 線形回帰モデル: y = Wx + b
def predict(W, b, X):
return W * X + b
# 損失関数 (平均二乗誤差)
def compute_loss(W, b, X, y):
predictions = predict(W, b, X)
return np.mean((predictions - y)**2)
# 勾配の計算
def compute_gradients(W, b, X, y):
predictions = predict(W, b, X)
dW = np.mean(2 * (predictions - y) * X)
db = np.mean(2 * (predictions - y))
return dW, db
# 確率的勾配降下法 (SGD) の実装
def stochastic_gradient_descent(W, b, X, y, learning_rate=0.01, iterations=100):
W_values = [W]
b_values = [b]
for i in range(iterations):
# ランダムにサンプルを選択
idx = np.random.randint(0, len(X))
X_i = X[idx:idx+1]
y_i = y[idx:idx+1]
# 勾配計算
dW, db = compute_gradients(W, b, X_i, y_i)
# パラメータ更新
W -= learning_rate * dW
b -= learning_rate * db
# パラメータの記録
W_values.append(W)
b_values.append(b)
return W, b, W_values, b_values
# 初期値設定
W = 0.0
b = 0.0
learning_rate = 0.01
iterations = 100
# SGDの適用
W, b, W_values, b_values = stochastic_gradient_descent(W, b, X, y, learning_rate, iterations)
# 最終的なWとb
print(f"最終的なW: {W}, b: {b}")
# 損失関数のプロット
loss_values = [compute_loss(W, b, X, y) for W, b in zip(W_values, b_values)]
plt.plot(loss_values)
plt.title('Loss Function (SGD)')
plt.xlabel('Iterations')
plt.ylabel('Loss')
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 目的関数 (二次関数) とその勾配
def f(x):
return x**2
def grad_f(x):
return 2 * x
# 減少ステップサイズを使った勾配降下法
def gradient_descent(grad_f, start_x, alpha=0.1, decay_rate=0.99, epsilon=1e-6, max_iter=1000):
x = start_x
history = [x]
for i in range(max_iter):
grad = grad_f(x)
if np.abs(grad) < epsilon:
print(f"Converged after {i} iterations")
break
x = x - alpha * grad
alpha *= decay_rate # ステップサイズを減少
history.append(x)
return x, history
# 初期値とパラメータ設定
start_x = 10.0 # 初期値
alpha = 0.1 # 初期のステップサイズ
decay_rate = 0.99 # ステップサイズの減少率
max_iter = 100 # 最大イテレーション回数
# 勾配降下法を実行
min_x, history = gradient_descent(grad_f, start_x, alpha, decay_rate)
# 結果のプロット
x_vals = np.linspace(-10, 10, 100)
y_vals = f(x_vals)
plt.plot(x_vals, y_vals, label="f(x) = x^2")
plt.plot(history, [f(x) for x in history], 'ro-', label="Gradient Descent Path")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.legend()
plt.title("Gradient Descent with Decreasing Step Size")
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 1. シグモイド関数
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# 2. ソフトマックス関数
def softmax(x):
e_x = np.exp(x - np.max(x)) # For numerical stability
return e_x / e_x.sum(axis=0)
# 3. 1次元のガウス関数
def gaussian_1d(x, mu=0, sigma=1):
return (1 / (sigma * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mu) / sigma) ** 2)
# 4. 2次元のガウス関数
def gaussian_2d(x, y, mu_x=0, mu_y=0, sigma_x=1, sigma_y=1):
return (1 / (2 * np.pi * sigma_x * sigma_y)) * np.exp(-0.5 * (((x - mu_x) / sigma_x) ** 2 + ((y - mu_y) / sigma_y) ** 2))
# x軸の範囲設定
x = np.linspace(-10, 10, 100)
# 1. シグモイド関数プロット
sigmoid_values = sigmoid(x)
# 2. ソフトマックス関数プロット
softmax_values = softmax(x)
# 3. 1次元のガウス関数プロット
gaussian_1d_values = gaussian_1d(x)
# 4. 2次元のガウス関数プロット用データ
x2 = np.linspace(-3, 3, 100)
y2 = np.linspace(-3, 3, 100)
X2, Y2 = np.meshgrid(x2, y2)
gaussian_2d_values = gaussian_2d(X2, Y2)
# プロット
plt.figure(figsize=(15, 10))
# 1. シグモイド関数のグラフ
plt.subplot(2, 2, 1)
plt.plot(x, sigmoid_values, label="Sigmoid Function", color="blue")
plt.title("Sigmoid Function")
plt.xlabel("x")
plt.ylabel("sigmoid(x)")
plt.grid(True)
# 2. ソフトマックス関数のグラフ
plt.subplot(2, 2, 2)
plt.plot(x, softmax_values, label="Softmax Function", color="green")
plt.title("Softmax Function")
plt.xlabel("x")
plt.ylabel("softmax(x)")
plt.grid(True)
# 3. 1次元のガウス関数のグラフ
plt.subplot(2, 2, 3)
plt.plot(x, gaussian_1d_values, label="1D Gaussian Function", color="red")
plt.title("1D Gaussian Function")
plt.xlabel("x")
plt.ylabel("Gaussian(x)")
plt.grid(True)
# 4. 2次元のガウス関数のグラフ
plt.subplot(2, 2, 4)
plt.contourf(X2, Y2, gaussian_2d_values, cmap="viridis")
plt.title("2D Gaussian Function")
plt.xlabel("x")
plt.ylabel("y")
plt.colorbar(label="Gaussian(x, y)")
plt.tight_layout()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
# 直線モデル: y = w1 * x + w0
def linear_regression_1D(X, Y):
n = len(X)
X_mean = np.mean(X)
Y_mean = np.mean(Y)
# 傾きw1と切片w0の解析解
w1 = np.sum((X - X_mean) * (Y - Y_mean)) / np.sum((X - X_mean) ** 2)
w0 = Y_mean - w1 * X_mean
return w1, w0
# 2次元面モデル: z = w1 * x1 + w2 * x2 + w0
def linear_regression_2D(X1, X2, Z):
A = np.column_stack((X1, X2, np.ones(len(X1))))
w = np.linalg.lstsq(A, Z, rcond=None)[0] # 解析解
return w # w1, w2, w0
# D次元線形回帰モデル: y = w1 * x1 + w2 * x2 + ... + wD * xD + w0
def linear_regression_D(X, Y):
X_augmented = np.column_stack((X, np.ones(X.shape[0])))
w = np.linalg.lstsq(X_augmented, Y, rcond=None)[0] # 解析解
return w # w1, w2, ..., wD, w0
# サンプルデータ生成
# 1次元直線モデルのサンプルデータ
X_1D = np.array([1, 2, 3, 4, 5])
Y_1D = np.array([2, 3, 4, 5, 6])
# 2次元面モデルのサンプルデータ
X1_2D = np.array([1, 2, 3, 4, 5])
X2_2D = np.array([2, 3, 4, 5, 6])
Z_2D = np.array([3, 5, 7, 9, 11])
# D次元線形回帰モデルのサンプルデータ
X_D = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]) # 2次元入力
Y_D = np.array([5, 7, 9, 11, 13])
# 1次元直線モデルの解析解
w1_1D, w0_1D = linear_regression_1D(X_1D, Y_1D)
print(f"1次元直線モデルのパラメータ: w1 = {w1_1D}, w0 = {w0_1D}")
# 2次元面モデルの解析解
w1_2D, w2_2D, w0_2D = linear_regression_2D(X1_2D, X2_2D, Z_2D)
print(f"2次元面モデルのパラメータ: w1 = {w1_2D}, w2 = {w2_2D}, w0 = {w0_2D}")
# D次元線形回帰モデルの解析解
w_D = linear_regression_D(X_D, Y_D)
print(f"D次元線形回帰モデルのパラメータ: {w_D}")
# プロット (1次元直線モデルの結果)
plt.scatter(X_1D, Y_1D, color="blue", label="Data points")
plt.plot(X_1D, w1_1D * X_1D + w0_1D, color="red", label="Fitted line")
plt.xlabel("X")
plt.ylabel("Y")
plt.title("1D Linear Regression")
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
# 原点を通らない面モデル: z = w1 * x1 + w2 * x2 + w0
def plane_model(X1, X2, Z):
A = np.column_stack((X1, X2, np.ones(len(X1))))
w = np.linalg.lstsq(A, Z, rcond=None)[0] # 解析解
return w # w1, w2, w0
# 線形基底関数モデル: φ(x) = w1 * φ1(x) + w2 * φ2(x) + ... + wN * φN(x)
def linear_basis_function_model(X, Y, degree):
poly = PolynomialFeatures(degree)
X_poly = poly.fit_transform(X)
model = LinearRegression()
model.fit(X_poly, Y)
return model, poly
# オーバーフィッティングの問題を視覚化
def overfitting_demo(X, Y, degree_high, degree_low):
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)
# 高次モデル（オーバーフィット）
model_high, poly_high = linear_basis_function_model(X_train, Y_train, degree_high)
Y_pred_train_high = model_high.predict(poly_high.transform(X_train))
Y_pred_test_high = model_high.predict(poly_high.transform(X_test))
# 低次モデル（アンダーフィット）
model_low, poly_low = linear_basis_function_model(X_train, Y_train, degree_low)
Y_pred_train_low = model_low.predict(poly_low.transform(X_train))
Y_pred_test_low = model_low.predict(poly_low.transform(X_test))
# モデルの評価
mse_train_high = mean_squared_error(Y_train, Y_pred_train_high)
mse_test_high = mean_squared_error(Y_test, Y_pred_test_high)
mse_train_low = mean_squared_error(Y_train, Y_pred_train_low)
mse_test_low = mean_squared_error(Y_test, Y_pred_test_low)
print(f"高次モデルのMSE (train): {mse_train_high}, (test): {mse_test_high}")
print(f"低次モデルのMSE (train): {mse_train_low}, (test): {mse_test_low}")
# プロット
plt.scatter(X, Y, color="blue", label="Data points")
# 高次モデルのプロット
X_plot = np.linspace(min(X), max(X), 100).reshape(-1, 1)
Y_plot_high = model_high.predict(poly_high.transform(X_plot))
plt.plot(X_plot, Y_plot_high, color="red", label=f"High Degree (Overfit), degree={degree_high}")
# 低次モデルのプロット
Y_plot_low = model_low.predict(poly_low.transform(X_plot))
plt.plot(X_plot, Y_plot_low, color="green", label=f"Low Degree (Underfit), degree={degree_low}")
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Overfitting vs Underfitting")
plt.legend()
plt.show()
# サンプルデータ生成
# 原点を通らない面モデルのサンプルデータ
X1_plane = np.array([1, 2, 3, 4, 5])
X2_plane = np.array([2, 3, 4, 5, 6])
Z_plane = np.array([5, 7, 9, 11, 13])
# 線形基底関数モデル用のサンプルデータ
X_basis = np.array([[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
Y_basis = np.array([2.5, 3.6, 4.9, 6.1, 7.2, 8.0, 8.8, 10.1, 11.2, 12.4])
# 原点を通らない面モデルの解析解
w1_plane, w2_plane, w0_plane = plane_model(X1_plane, X2_plane, Z_plane)
print(f"原点を通らない面モデルのパラメータ: w1 = {w1_plane}, w2 = {w2_plane}, w0 = {w0_plane}")
# 線形基底関数モデルの実行（2次元多項式基底関数を使用）
degree_basis = 2
model_basis, poly_basis = linear_basis_function_model(X_basis, Y_basis, degree_basis)
Y_pred_basis = model_basis.predict(poly_basis.transform(X_basis))
print(f"線形基底関数モデルの係数: {model_basis.coef_}")
print(f"線形基底関数モデルの切片: {model_basis.intercept_}")
# オーバーフィッティングの問題の視覚化（低次と高次の比較）
degree_high = 9 # 高次モデル
degree_low = 1 # 低次モデル
overfitting_demo(X_basis, Y_basis, degree_high, degree_low)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss, accuracy_score
from sklearn.datasets import make_classification
from mpl_toolkits.mplot3d import Axes3D
# 1次元クラス分類用のデータ生成（修正済み）
def generate_1d_classification_data():
X, y = make_classification(n_samples=100, n_features=1, n_informative=1, n_redundant=0, n_repeated=0, n_classes=2, n_clusters_per_class=1, random_state=42)
return X, y
# 2次元クラス分類用のデータ生成（2クラス）
def generate_2d_classification_data():
X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_classes=2, n_clusters_per_class=1, random_state=42)
return X, y
# 2次元クラス分類用のデータ生成（3クラス）
def generate_2d_classification_data_3classes():
X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_classes=3, n_clusters_per_class=1, random_state=42)
return X, y
# ロジスティック回帰モデルのトレーニングと評価
def logistic_regression_model(X, y, num_classes=2):
model = LogisticRegression(multi_class='ovr' if num_classes == 2 else 'multinomial', solver='lbfgs')
model.fit(X, y)
return model
# データプロット（1次元クラス分類）
def plot_1d_classification(X, y, model):
plt.scatter(X, y, color='blue', label='Data points')
X_plot = np.linspace(X.min(), X.max(), 100).reshape(-1, 1)
y_prob = model.predict_proba(X_plot)[:, 1]
plt.plot(X_plot, y_prob, color='red', label='Logistic regression')
plt.xlabel("X")
plt.ylabel("Probability")
plt.title("1D Logistic Regression")
plt.legend()
plt.show()
# データプロット（2次元クラス分類）
def plot_2d_classification(X, y, model, num_classes=2):
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', label='Data points')
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.5, cmap='viridis')
plt.xlabel("X1")
plt.ylabel("X2")
plt.title(f"2D Logistic Regression (Classes={num_classes})")
plt.show()
# ロジスティック回帰の結果を評価
def evaluate_model(model, X, y):
y_pred = model.predict(X)
y_prob = model.predict_proba(X)
loss = log_loss(y, y_prob)
accuracy = accuracy_score(y, y_pred)
print(f"Log-Loss: {loss:.4f}, Accuracy: {accuracy:.4f}")
# 1次元クラス分類の実行
X_1d, y_1d = generate_1d_classification_data()
X_train_1d, X_test_1d, y_train_1d, y_test_1d = train_test_split(X_1d, y_1d, test_size=0.2, random_state=42)
model_1d = logistic_regression_model(X_train_1d, y_train_1d, num_classes=2)
evaluate_model(model_1d, X_test_1d, y_test_1d)
plot_1d_classification(X_test_1d, y_test_1d, model_1d)
# 2次元クラス分類の実行（2クラス）
X_2d, y_2d = generate_2d_classification_data()
X_train_2d, X_test_2d, y_train_2d, y_test_2d = train_test_split(X_2d, y_2d, test_size=0.2, random_state=42)
model_2d = logistic_regression_model(X_train_2d, y_train_2d, num_classes=2)
evaluate_model(model_2d, X_test_2d, y_test_2d)
plot_2d_classification(X_test_2d, y_test_2d, model_2d, num_classes=2)
# 2次元クラス分類の実行（3クラス）
X_3d, y_3d = generate_2d_classification_data_3classes()
X_train_3d, X_test_3d, y_train_3d, y_test_3d = train_test_split(X_3d, y_3d, test_size=0.2, random_state=42)
model_3d = logistic_regression_model(X_train_3d, y_train_3d, num_classes=3)
evaluate_model(model_3d, X_test_3d, y_test_3d)
plot_2d_classification(X_test_3d, y_test_3d, model_3d, num_classes=3)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import log_loss, accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification
# 1次元クラス分類用データ生成
def generate_1d_classification_data():
X, y = make_classification(n_samples=100, n_features=1, n_informative=1, n_redundant=0, n_repeated=0, n_classes=2, n_clusters_per_class=1, random_state=42)
return X, y
# 2次元クラス分類用データ生成（2クラス）
def generate_2d_classification_data():
X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_repeated=0, n_classes=2, n_clusters_per_class=1, random_state=42)
return X, y
# 2次元クラス分類用データ生成（3クラス）
def generate_2d_classification_data_3classes():
X, y = make_classification(n_samples=100, n_features=2, n_informative=2, n_redundant=0, n_repeated=0, n_classes=3, n_clusters_per_class=1, random_state=42)
return X, y
# ロジスティック回帰モデルのトレーニングと評価
def logistic_regression_model(X, y, num_classes=2):
model = LogisticRegression(multi_class='ovr' if num_classes == 2 else 'multinomial', solver='lbfgs')
model.fit(X, y)
return model
# データプロット（1次元クラス分類）
def plot_1d_classification(X, y, model):
plt.scatter(X, y, color='blue', label='Data points')
X_plot = np.linspace(X.min(), X.max(), 100).reshape(-1, 1)
y_prob = model.predict_proba(X_plot)[:, 1]
plt.plot(X_plot, y_prob, color='red', label='Logistic regression')
plt.xlabel("X")
plt.ylabel("Probability")
plt.title("1D Logistic Regression")
plt.legend()
plt.show()
# データプロット（2次元クラス分類）
def plot_2d_classification(X, y, model, num_classes=2):
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', label='Data points')
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.5, cmap='viridis')
plt.xlabel("X1")
plt.ylabel("X2")
plt.title(f"2D Logistic Regression (Classes={num_classes})")
plt.show()
# モデル評価（交差エントロピー誤差と正解率）
def evaluate_model(model, X, y):
y_pred = model.predict(X)
y_prob = model.predict_proba(X)
loss = log_loss(y, y_prob)
accuracy = accuracy_score(y, y_pred)
print(f"Log-Loss: {loss:.4f}, Accuracy: {accuracy:.4f}")
# 勾配法（サンプル例: 簡単な勾配法による更新ステップ）
def gradient_descent(X, y, learning_rate=0.01, num_iterations=1000):
m, n = X.shape
weights = np.zeros(n)
bias = 0
for _ in range(num_iterations):
linear_model = np.dot(X, weights) + bias
predictions = 1 / (1 + np.exp(-linear_model)) # シグモイド関数
dw = (1 / m) * np.dot(X.T, (predictions - y))
db = (1 / m) * np.sum(predictions - y)
weights -= learning_rate * dw
bias -= learning_rate * db
return weights, bias
# 1次元クラス分類の実行
X_1d, y_1d = generate_1d_classification_data()
X_train_1d, X_test_1d, y_train_1d, y_test_1d = train_test_split(X_1d, y_1d, test_size=0.2, random_state=42)
model_1d = logistic_regression_model(X_train_1d, y_train_1d, num_classes=2)
evaluate_model(model_1d, X_test_1d, y_test_1d)
plot_1d_classification(X_test_1d, y_test_1d, model_1d)
# 2次元クラス分類の実行（2クラス）
X_2d, y_2d = generate_2d_classification_data()
X_train_2d, X_test_2d, y_train_2d, y_test_2d = train_test_split(X_2d, y_2d, test_size=0.2, random_state=42)
model_2d = logistic_regression_model(X_train_2d, y_train_2d, num_classes=2)
evaluate_model(model_2d, X_test_2d, y_test_2d)
plot_2d_classification(X_test_2d, y_test_2d, model_2d, num_classes=2)
# 2次元クラス分類の実行（3クラス）
X_3d, y_3d = generate_2d_classification_data_3classes()
X_train_3d, X_test_3d, y_train_3d, y_test_3d = train_test_split(X_3d, y_3d, test_size=0.2, random_state=42)
model_3d = logistic_regression_model(X_train_3d, y_train_3d, num_classes=3)
evaluate_model(model_3d, X_test_3d, y_test_3d)
plot_2d_classification(X_test_3d, y_test_3d, model_3d, num_classes=3)
# 勾配法の例を実行（1次元データ）
weights, bias = gradient_descent(X_train_1d, y_train_1d)
print(f"Weights: {weights}, Bias: {bias}")
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
# ニューロンモデル
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return sigmoid(x) * (1 - sigmoid(x))
# 2層フィードフォワードニューラルネットワークの実装
class TwoLayerNN:
def __init__(self, input_size, hidden_size, output_size):
self.input_size = input_size
self.hidden_size = hidden_size
self.output_size = output_size
# 初期化
self.W1 = np.random.randn(self.input_size, self.hidden_size)
self.b1 = np.zeros((1, self.hidden_size))
self.W2 = np.random.randn(self.hidden_size, self.output_size)
self.b2 = np.zeros((1, self.output_size))
def forward(self, X):
self.hidden = sigmoid(np.dot(X, self.W1) + self.b1)
self.output = sigmoid(np.dot(self.hidden, self.W2) + self.b2)
return self.output
def backward(self, X, y, learning_rate=0.01):
m = X.shape[0]
output_error = self.output - y
output_delta = output_error * sigmoid_derivative(self.output)
hidden_error = np.dot(output_delta, self.W2.T)
hidden_delta = hidden_error * sigmoid_derivative(self.hidden)
# パラメータの更新
self.W2 -= learning_rate * np.dot(self.hidden.T, output_delta) / m
self.b2 -= learning_rate * np.sum(output_delta, axis=0) / m
self.W1 -= learning_rate * np.dot(X.T, hidden_delta) / m
self.b1 -= learning_rate * np.sum(hidden_delta, axis=0) / m
def train(self, X, y, epochs=1000, learning_rate=0.01):
for epoch in range(epochs):
self.forward(X)
self.backward(X, y, learning_rate)
# データの生成と前処理
X, y = make_classification(n_samples=1000, n_features=4, n_informative=2, n_redundant=0, n_repeated=0, n_classes=2, random_state=42)
y = y.reshape(-1, 1) # ニューラルネットワークのために y を列ベクトルに変換
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# ニューラルネットワークの実行
nn = TwoLayerNN(input_size=4, hidden_size=5, output_size=1)
nn.train(X_train, y_train, epochs=1000, learning_rate=0.01)
# テストデータでの評価
y_pred = nn.forward(X_test)
y_pred = (y_pred > 0.5).astype(int)
accuracy = accuracy_score(y_test, y_pred)
print(f'ニューラルネットワークの精度: {accuracy:.4f}')
# Kerasでニューラルネットワークモデルを構築
def build_keras_model():
model = Sequential()
model.add(Dense(5, input_dim=4, activation='sigmoid'))
model.add(Dense(1, activation='sigmoid'))
model.compile(optimizer=SGD(learning_rate=0.01), loss='binary_crossentropy', metrics=['accuracy'])
return model
# Kerasでのモデルのトレーニングと評価
keras_model = build_keras_model()
keras_model.fit(X_train, y_train, epochs=100, verbose=0)
loss, accuracy = keras_model.evaluate(X_test, y_test, verbose=0)
print(f'Kerasモデルの精度: {accuracy:.4f}')
import numpy as np
import matplotlib.pyplot as plt
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, Dropout
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.optimizers import Adam
# MNISTデータセットのロード
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# データの前処理
X_train = X_train.reshape(-1, 28, 28, 1).astype('float32') / 255.0
X_test = X_test.reshape(-1, 28, 28, 1).astype('float32') / 255.0
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)
# 畳み込みニューラルネットワークモデルの構築
model = Sequential()
# 畳み込み層
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
# Flatten層と全結合層
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))
# モデルのコンパイル
model.compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy'])
# モデルのトレーニング
history = model.fit(X_train, y_train, epochs=10, batch_size=64, validation_split=0.2, verbose=1)
# モデルの評価
test_loss, test_accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f'テストデータでの損失: {test_loss:.4f}')
print(f'テストデータでの精度: {test_accuracy:.4f}')
# トレーニングと検証の損失と精度のプロット
plt.figure(figsize=(12, 4))
# 精度のプロット
plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='train accuracy')
plt.plot(history.history['val_accuracy'], label='validation accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
# 損失のプロット
plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='train loss')
plt.plot(history.history['val_loss'], label='validation loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
# 2次元入力データの生成
np.random.seed(42)
n_samples = 500
X = np.concatenate([np.random.randn(n_samples // 2, 2) * 0.5 + np.array([1, 1]),
np.random.randn(n_samples // 2, 2) * 0.5 + np.array([-1, -1])])
# K-meansクラスタリング
kmeans = KMeans(n_clusters=2, random_state=42)
kmeans_labels = kmeans.fit_predict(X)
kmeans_centers = kmeans.cluster_centers_
# ガウス混合モデルのフィッティング
gmm = GaussianMixture(n_components=2, random_state=42)
gmm_labels = gmm.fit_predict(X)
gmm_means = gmm.means_
# 結果の可視化
fig, axs = plt.subplots(1, 2, figsize=(12, 6))
# K-meansの結果
axs[0].scatter(X[:, 0], X[:, 1], c=kmeans_labels, s=30, cmap='viridis')
axs[0].scatter(kmeans_centers[:, 0], kmeans_centers[:, 1], c='red', s=100, alpha=0.75, marker='X')
axs[0].set_title('K-means Clustering')
# GMMの結果
axs[1].scatter(X[:, 0], X[:, 1], c=gmm_labels, s=30, cmap='viridis')
axs[1].scatter(gmm_means[:, 0], gmm_means[:, 1], c='red', s=100, alpha=0.75, marker='X')
axs[1].set_title('Gaussian Mixture Model')
plt.show()
# EMアルゴリズムの概要
# Step 0: 初期化
print("Step 0: Initialization")
print("Initialize the parameters (means, covariances, and weights)")
# Step 1: E Step
print("\nStep 1: E Step")
print("Calculate the probability of each point belonging to each cluster")
# Step 2: M Step
print("\nStep 2: M Step")
print("Update the parameters (means, covariances, and weights) based on the probabilities")
# 尤度の計算
log_likelihood = gmm.score(X)
print("\nLikelihood (Log-Likelihood) of the data given the model: ", log_likelihood)
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from transformers import BertTokenizer, BertModel
from sklearn.datasets import make_moons
# 1. モンテカルロツリーサーチの概要実装
class MCTSNode:
def __init__(self, state, parent=None):
self.state = state
self.parent = parent
self.children = []
self.visits = 0
self.value = 0
def select_child(self):
# UCB1 を用いた子ノードの選択
return max(self.children, key=lambda x: x.value / (x.visits + 1e-5) + np.sqrt(2 * np.log(self.visits) / (x.visits + 1e-5)))
def mcts_simulation():
root = MCTSNode(state="root")
# 簡易的なMCTSの実行
for _ in range(10):
node = root
while node.children:
node = node.select_child()
node.visits += 1
node.value += np.random.random() # ランダムな報酬
return root
# 2. GAN の概要実装 (ディープラーニングを用いた簡易モデル)
class SimpleGAN(nn.Module):
def __init__(self):
super(SimpleGAN, self).__init__()
self.generator = nn.Sequential(
nn.Linear(10, 32),
nn.ReLU(),
nn.Linear(32, 2)
)
self.discriminator = nn.Sequential(
nn.Linear(2, 32),
nn.ReLU(),
nn.Linear(32, 1),
nn.Sigmoid()
)
def forward(self, x):
return self.generator(x)
def gan_example():
gan = SimpleGAN()
optimizer = optim.Adam(gan.parameters(), lr=0.001)
# 簡単なトレーニングループ
for _ in range(5):
real_data, _ = make_moons(n_samples=10, noise=0.1)
fake_data = gan.generator(torch.randn(10, 10).float())
real_labels = torch.ones(10, 1)
fake_labels = torch.zeros(10, 1)
real_loss = torch.mean((gan.discriminator(torch.tensor(real_data).float()) - real_labels) ** 2)
fake_loss = torch.mean((gan.discriminator(fake_data) - fake_labels) ** 2)
loss = real_loss + fake_loss
optimizer.zero_grad()
loss.backward()
optimizer.step()
return fake_data
# 3. BERT の概要実装
def bert_example(text="Hello, how are you?"):
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased')
inputs = tokenizer(text, return_tensors="pt")
outputs = model(**inputs)
return outputs.last_hidden_state
# 5. 量子アニーリングの概要実装
def quantum_annealing_example():
# ここでは量子ビットの簡単なエネルギー最適化をシミュレーション
energy = np.random.random()
return energy
# 各技術のデモを実行
mcts_result = mcts_simulation()
gan_result = gan_example()
bert_result = bert_example()
# quantum_cryptography_result = quantum_cryptography_example() # コメントアウト
quantum_annealing_result = quantum_annealing_example()
print("MCTS Simulation Result:", mcts_result)
print("GAN Generated Data:", gan_result)
print("BERT Output:", bert_result)
# print("Quantum Cryptography Result:", quantum_cryptography_result) # コメントアウト
print("Quantum Annealing Energy:", quantum_annealing_result)