def compute_network_metrics(G, area_m2=None, intersection_degree_threshold=3, clean_int_tol=None):
    # 1. 基本構造指標の算出
    n = len(G.nodes)
    e = len(G.edges)
    p = nx.number_connected_components(G.to_undirected())
    
    # 2. 回路性指標の算出
    mu = e - n + p
    alpha = mu / (2 * n - 5) if n > 2 else 0
    beta = e / n if n > 0 else 0
    gamma = e / (3 * (n - 2)) if n > 2 else 0
    
    # 3. 中心性指標の算出
    degree_centrality = nx.degree_centrality(G)
    closeness_centrality = nx.closeness_centrality(G)
    betweenness_centrality = nx.betweenness_centrality(G)
    
    # 4. その他の指標算出...

1. 標準化後の特徴量行列 X を入力
2. 分散による第一次フィルタリング
3. 相関による第二次フィルタリング（貪欲アルゴリズム）
4. 選定された特徴量インデックスを出力

variance_threshold = 0.05  # 分散の最小閾値
variances = X.var()
variance_mask = variances > variance_threshold

例：基本構造指標
- n_nodes (ノード数): 分散 = 0.245 → 通過
- p_components (接続成分数): 分散 = 0.012 → 除外

correlation_threshold = 0.7  # 相関係数の閾値
correlation_matrix = X_filtered.corr().abs()

selected_features = []
remaining_features = feature_list.copy()

while remaining_features:
    # 1. 残りの特徴量から最も分散の大きいものを選択
    best_feature = max(remaining_features, key=lambda f: variances[f])
    selected_features.append(best_feature)
    
    # 2. 選択された特徴量と高相関の特徴量を除去
    for other_feature in remaining_features:
        if correlation_matrix[best_feature][other_feature] > 0.7:
            remaining_features.remove(other_feature)

基本構造指標：
- n_nodes, e_edges, p_components, basic_n, basic_m

回路性指標：
- circuit_index_mu, alpha_index, beta_index, gamma_index
- mean_circuit_index_mu_a, basic_k_avg

距離・長さ指標：
- avg_shortest_path_Di, total_edge_length_L
- basic_edge_length_total, basic_edge_length_avg
- basic_street_length_total, basic_street_length_avg
- avg_circuity_A, basic_circuity_avg

密度指標：
- road_density_Dl_m_per_ha, intersection_density_Dc_per_ha
- basic_node_density_km, basic_intersection_density_km
- basic_edge_density_km, basic_street_density_km
- basic_clean_intersection_density_km

中心性指標：
- degree_centrality_mean, degree_centrality_std
- closeness_centrality_mean, closeness_centrality_std
- betweenness_centrality_mean, betweenness_centrality_std

Integration指標：
- integration_global_mean, integration_global_std
- integration_local_r3_mean, integration_local_r3_std

その他：
- area_m2, intersection_count_deg≥3, basic_intersection_count
- basic_street_segment_count, basic_streets_per_node_avg
- basic_self_loop_proportion, basic_clean_intersection_count

ステップ1: 分散フィルタ (閾値: 0.05)
- 通過: 35個の特徴量
- 除外: 8個の特徴量（低分散）

ステップ2: 相関フィルタ (閾値: 0.7)
- 高相関ペア検出: 例
  * total_edge_length_L ↔ basic_edge_length_total (r=0.98)
  * n_nodes ↔ basic_n (r=0.95)
  * intersection_density_Dc_per_ha ↔ basic_intersection_density_km (r=0.89)

- 貪欲選定結果: 最終的に15-20個程度の特徴量を選定

# 削減率
reduction_rate = (1 - selected_count / original_count) * 100

# 最大相関値（選定後）
max_correlation = correlation_matrix_selected.abs().max().max()

# 分散保持率
variance_retention = sum(variances[selected]) / sum(variances[all])

# 1. 欠損値処理
imputer = SimpleImputer(strategy='median')

# 2. 異常値処理（IQR法）
Q1, Q3 = data.quantile([0.25, 0.75])
IQR = Q3 - Q1
data_clipped = data.clip(Q1 - 3*IQR, Q3 + 3*IQR)

# 3. 標準化
scaler = RobustScaler()
data_scaled = scaler.fit_transform(data_clipped)

# 相関行列の可視化
sns.heatmap(correlation_matrix_selected, annot=True)

# VIF（分散拡大係数）の計算
from statsmodels.stats.outliers_influence import variance_inflation_factor
vif_values = [variance_inflation_factor(X, i) for i in range(X.shape[1])]

y(λ) = {
    (y^λ - 1) / λ    (λ ≠ 0)
    ln(y)            (λ = 0)
}

Stage 1: 基本適用条件の確認
Stage 2: 正規性の統計的評価
Stage 3: 変換効果の定量評価
Stage 4: 総合判定と推奨度評価

def evaluate_basic_conditions(data):
    finite_data = data[np.isfinite(data)]
    
    # 1. 正の値のみか
    has_positive_values = len(finite_data) > 0 and np.all(finite_data > 0)
    
    # 2. 分散が存在するか
    has_variance = len(finite_data) > 1 and np.var(finite_data) > 1e-10
    
    # 3. 十分なサンプル数があるか
    sufficient_sample_size = len(finite_data) >= 30
    
    return has_positive_values, has_variance, sufficient_sample_size

from scipy.stats import shapiro

stat, p_value = shapiro(sample_data)
is_normal = p_value > 0.05

from scipy.stats import anderson

result = anderson(sample_data, dist='norm')
critical_value = result.critical_values[2]  # 5%水準
is_normal = result.statistic < critical_value

from scipy.stats import kstest

standardized = (sample_data - np.mean(sample_data)) / np.std(sample_data)
stat, p_value = kstest(standardized, 'norm')
is_normal = p_value > 0.05

def assess_normality(data, alpha=0.05):
    """複数の正規性検定による総合判定"""
    
    # 各検定の実行
    shapiro_result = perform_shapiro_test(data, alpha)
    anderson_result = perform_anderson_test(data, alpha)
    ks_result = perform_ks_test(data, alpha)
    
    # 総合判定：いずれかの検定で正規性が認められれば正規分布と判定
    is_normal = any([
        shapiro_result.is_normal,
        anderson_result.is_normal,
        ks_result.is_normal
    ])
    
    return is_normal

from scipy.stats import boxcox_normmax, boxcox

# 最適λの探索
lambda_optimal = boxcox_normmax(data)

# 変換の実行
if abs(lambda_optimal) < 1e-6:  # λ ≈ 0
    transformed_data = np.log(data)
    lambda_param = 0.0
else:
    transformed_data, lambda_param = boxcox(data, lmbda=lambda_optimal)

# 変換前後のp-value比較
original_p_values = [result.p_value for result in original_normality_tests]
transformed_p_values = [result.p_value for result in transformed_normality_tests]

original_avg_p = np.mean(original_p_values)
transformed_avg_p = np.mean(transformed_p_values)

normality_improvement = transformed_avg_p / original_avg_p

from scipy import stats

# 歪度の改善
original_skewness = abs(stats.skew(original_data))
transformed_skewness = abs(stats.skew(transformed_data))
skewness_improvement = original_skewness - transformed_skewness

# 尖度の改善
original_kurtosis = abs(stats.kurtosis(original_data))
transformed_kurtosis = abs(stats.kurtosis(transformed_data))
kurtosis_improvement = original_kurtosis - transformed_kurtosis

def make_final_decision(original_normality, transformed_normality,
                       skewness_improvement, normality_improvement, lambda_param):
    """最終的な適用判定"""
    
    # 1. 正規性が改善されたか
    normality_improved = normality_improvement >= 2.0
    
    # 2. 歪度が改善されたか
    skewness_improved = skewness_improvement > 0.5
    
    # 3. 変換後に正規分布に近づいたか
    became_more_normal = any(result.is_normal for result in transformed_normality.values())
    
    # 4. λパラメータが合理的な範囲か
    reasonable_lambda = -3 <= lambda_param <= 3
    
    # 総合判定
    should_apply = (normality_improved or skewness_improved or became_more_normal) and reasonable_lambda
    
    return should_apply

総指標数: 43
├─ 基本条件満足: 35指標
├─ 基本条件不満足: 8指標
│
適用判定結果:
├─ Box-Cox適用推奨: 0指標 (0%)
├─ Box-Cox適用非推奨: 35指標 (81.4%)
└─ 既に正規分布: 8指標 (18.6%)

# 大サンプルでの正規性検定の効率化
def test_normality_efficiently(data, sample_size=1000):
    if len(data) > sample_size:
        # ランダムサンプリングで計算時間を短縮
        sampled_data = np.random.choice(data, sample_size, replace=False)
    else:
        sampled_data = data
    
    return perform_normality_tests(sampled_data)

def robust_boxcox_transform(data):
    """数値的に安定なBox-Cox変換"""
    
    # 最小値が正になるよう調整
    min_val = data.min()
    if min_val <= 0:
        shift = abs(min_val) + 1e-6
        data_shifted = data + shift
    else:
        data_shifted = data
    
    try:
        transformed_data, lambda_param = boxcox(data_shifted)
        return transformed_data, lambda_param
    except Exception as e:
        print(f"Box-Cox変換失敗: {e}")
        return data, None

# 変換前後の分布比較
def visualize_transformation_effect(original, transformed, metric_name):
    fig, axes = plt.subplots(1, 2, figsize=(12, 5))
    
    # 変換前
    axes[0].hist(original, bins=30, alpha=0.7, label='変換前')
    axes[0].set_title(f'{metric_name} - 変換前')
    
    # 変換後
    axes[1].hist(transformed, bins=30, alpha=0.7, label='変換後', color='red')
    axes[1].set_title(f'{metric_name} - 変換後')
    
    plt.tight_layout()
    plt.show()

# 分野特化型の設定例
class DomainSpecificBoxCoxEvaluator(BoxCoxEvaluator):
    def __init__(self, domain="general"):
        if domain == "finance":
            # 金融データ向け設定
            super().__init__(alpha=0.01, min_improvement_factor=1.5)
        elif domain == "biology":
            # 生物学データ向け設定
            super().__init__(alpha=0.05, min_improvement_factor=2.5)
        else:
            # デフォルト設定
            super().__init__()