123 lines
4.2 KiB
Python
123 lines
4.2 KiB
Python
from experiments.synthetic_data.analysis.processing_time_analysis import mean_l
|
|
from experiments.synthetic_data.analysis.processing_time_analysis import regression_k3
|
|
from experiments.synthetic_data.analysis.processing_time_analysis import regression_m
|
|
from experiments.synthetic_data.analysis.call_number_analysis import nonlinear_regression
|
|
import numpy as np
|
|
import pandas as pd
|
|
import os
|
|
import matplotlib.pyplot as plt
|
|
from sklearn.metrics import mean_squared_error, mean_absolute_error
|
|
|
|
def k3(V):
|
|
return k3_a * np.exp(-k3_b * V) + k3_c
|
|
|
|
def m(V):
|
|
return m_a * np.log2(V) + m_b
|
|
|
|
def relax_success(E, S, AVG_DEG):
|
|
relax_attempts = E
|
|
relax_success_ratio = (rs_a * np.log(S) + rs_b) * AVG_DEG ** rs_c
|
|
return relax_attempts * relax_success_ratio
|
|
|
|
|
|
def runtime_predict(V, D, S):
|
|
E = V * (V - 1) * D
|
|
AVG_DEG = (V - 1) * D
|
|
if AVG_DEG < 1:
|
|
return False
|
|
|
|
runtime = V * l + E * k3(V) + relax_success(E, S, AVG_DEG) * m(V)
|
|
print(relax_success(E, S, AVG_DEG))
|
|
# runtime_eq = f"[V * {l}] + [E * {k3_a} * exp(-{k3_b} * V) + {k3_c}] + [E * ({rs_a} * log(S) + {rs_b}) * AVG_DEG ** {rs_c} * {m_a} * log_2(V) + {m_b}]"
|
|
|
|
return runtime
|
|
|
|
|
|
l = mean_l()
|
|
k3_a, k3_b, k3_c = regression_k3()
|
|
m_a, m_b = regression_m()
|
|
rs_a, rs_b, rs_c = nonlinear_regression()
|
|
|
|
csv_file = "results/synthetic_data/raw/20260421_031740.csv"
|
|
save_folder = f"results/synthetic_data/derived/{os.path.splitext(os.path.basename(csv_file))[0]}/prediction_result"
|
|
os.makedirs(save_folder, exist_ok=True)
|
|
|
|
df = pd.read_csv(csv_file)
|
|
df = df[df["algorithm"] == "binary"].copy()
|
|
|
|
records = []
|
|
for row in df.itertuples():
|
|
predicted = runtime_predict(row.nodes, row.density, row.sigma)
|
|
if predicted is False:
|
|
continue
|
|
records.append({
|
|
"nodes": row.nodes,
|
|
"density": row.density,
|
|
"sigma": row.sigma,
|
|
"trial": row.trial,
|
|
"real_time": row.time,
|
|
"predict_time": predicted,
|
|
"abs_error": abs(row.time - predicted),
|
|
"rel_error": abs(row.time - predicted) / row.time,
|
|
})
|
|
|
|
result = pd.DataFrame(records)
|
|
out_path = os.path.join(save_folder, "prediction.csv")
|
|
result.to_csv(out_path, index=False)
|
|
print(f"Saved {len(result)} rows → {out_path}")
|
|
|
|
real = result["real_time"].to_numpy()
|
|
pred = result["predict_time"].to_numpy()
|
|
|
|
ss_res = np.sum((real - pred) ** 2)
|
|
ss_tot = np.sum((real - real.mean()) ** 2)
|
|
r2 = 1 - ss_res / ss_tot
|
|
print(f"R² = {r2:.4f}")
|
|
|
|
rmse = np.sqrt(mean_squared_error(real, pred))
|
|
mae = mean_absolute_error(real, pred)
|
|
|
|
print(f"RMSE: {rmse:.4f} s") # 평균 제곱 오차의 제곱근
|
|
print(f"MAE: {mae:.4f} s") # 평균 절대 오차
|
|
|
|
mn, mx = min(real.min(), pred.min()), max(real.max(), pred.max())
|
|
|
|
fig, ax = plt.subplots(figsize=(6, 6))
|
|
ax.scatter(real, pred, s=5, alpha=0.3, color="steelblue")
|
|
ax.plot([mn, mx], [mn, mx], color="red", linewidth=1.5, linestyle="--", label="y = x")
|
|
ax.set_xlabel("real_time [s]")
|
|
ax.set_ylabel("predict_time [s]")
|
|
ax.set_title(f"Predicted vs Real Runtime R²={r2:.4f}")
|
|
ax.legend(fontsize=9)
|
|
ax.grid(True, alpha=0.4)
|
|
fig.tight_layout()
|
|
fig.savefig(os.path.join(save_folder, "predicted_vs_real.png"), dpi=300)
|
|
plt.close(fig)
|
|
print(f"Saved: {save_folder}/predicted_vs_real.png")
|
|
|
|
# rel_error distribution
|
|
rel_err = result["rel_error"].to_numpy()
|
|
|
|
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
|
|
|
|
# histogram
|
|
axes[0].hist(rel_err, bins=50, color="steelblue", edgecolor="none", alpha=0.8)
|
|
axes[0].axvline(np.median(rel_err), color="red", linestyle="--", linewidth=1.5, label=f"median={np.median(rel_err):.3f}")
|
|
axes[0].axvline(np.mean(rel_err), color="orange", linestyle="--", linewidth=1.5, label=f"mean={np.mean(rel_err):.3f}")
|
|
axes[0].set_xlabel("rel_error")
|
|
axes[0].set_ylabel("count")
|
|
axes[0].set_title("Relative Error Distribution")
|
|
axes[0].legend(fontsize=9)
|
|
axes[0].grid(True, alpha=0.4)
|
|
|
|
# rel_error vs real_time
|
|
axes[1].scatter(real, rel_err, s=5, alpha=0.3, color="steelblue")
|
|
axes[1].set_xlabel("real_time [s]")
|
|
axes[1].set_ylabel("rel_error")
|
|
axes[1].set_title("Relative Error vs Real Time")
|
|
axes[1].grid(True, alpha=0.4)
|
|
|
|
fig.tight_layout()
|
|
fig.savefig(os.path.join(save_folder, "rel_error_dist.png"), dpi=300)
|
|
plt.close(fig)
|
|
print(f"Saved: {save_folder}/rel_error_dist.png") |