sigma图的计算和绘图

import numpy as np

def calculate_sigma(y_true, y_pred):
    """
    计算每个样本的残差标准差 (sigma)
    """
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)

    # 残差
    residuals = y_true - y_pred

    # 残差的标准差 (总体标准差)
    sigma = np.std(residuals)

    return sigma, residuals.tolist()

# 示例
y_true = [3.0, 5.0, 7.5, 10.0]
y_pred = [2.8, 5.2, 7.0, 9.8]

sigma, residuals = calculate_sigma(y_true, y_pred)
print("sigma:", sigma)
print("residuals:", residuals)  # 每个点的残差可用于绘制散点图

def downsample(residuals, step=10):
    return residuals[::step]

import numpy as np

def aggregate_residuals(residuals, bin_size=100):
    n_bins = len(residuals) // bin_size
    agg_data = []
    for i in range(n_bins):
        segment = residuals[i*bin_size:(i+1)*bin_size]
        agg_data.append({
            "mean": float(np.mean(segment)),
            "std": float(np.std(segment)),
            "start": i*bin_size,
            "end": (i+1)*bin_size
        })
    return agg_data

import numpy as np

def calculate_sigma(y_true, y_pred):
    """
    计算残差及其标准差
    """
    residuals = np.array(y_true) - np.array(y_pred)
    sigma = float(np.std(residuals))
    return sigma, residuals.tolist()

def find_best_epoch(loss_list):
    """
    找出loss最小的轮次索引
    """
    return int(np.argmin(loss_list))

def aggregate_residuals(residuals, bin_size=100):
    """
    将残差数据按区间聚合，减少前端绘图数据量
    """
    agg_data = []
    n_bins = len(residuals) // bin_size
    for i in range(n_bins):
        segment = residuals[i*bin_size:(i+1)*bin_size]
        agg_data.append({
            "mean": float(np.mean(segment)),
            "std": float(np.std(segment)),
            "start": i*bin_size,
            "end": (i+1)*bin_size
        })
    return agg_data

# ======= 模拟训练过程 =======

epochs = 50
samples = 5000

# 模拟真实值
y_true = np.linspace(0, 10, samples)

# 模拟每轮预测与loss
y_preds = [y_true + np.random.normal(0, 1/(ep+1), samples) for ep in range(epochs)]
loss_list = [np.mean((y_true - y_pred)**2) for y_pred in y_preds]

# 每轮sigma记录
sigma_list = []
for y_pred in y_preds:
    sigma, _ = calculate_sigma(y_true, y_pred)
    sigma_list.append(sigma)

# 找出loss最小轮次
best_epoch = find_best_epoch(loss_list)
best_y_pred = y_preds[best_epoch]

# 获取残差数据
_, residuals = calculate_sigma(y_true, best_y_pred)

# 降采样 / 聚合
agg_residuals = aggregate_residuals(residuals, bin_size=100)

# 返回给前端的数据
result = {
    "epochs": list(range(1, epochs+1)),
    "lossList": loss_list,
    "sigmaList": sigma_list,
    "bestEpochResiduals": residuals,
    "sigma": sigma_list[best_epoch],
    "aggregatedResiduals": agg_residuals
}

print(result.keys())  # ['epochs', 'lossList', 'sigmaList', 'bestEpochResiduals', 'sigma', 'aggregatedResiduals']

import numpy as np

def calculate_residuals(y_true, y_pred, use_percentage=False):
    """
    计算残差及其标准差
    :param y_true: 真实值数组
    :param y_pred: 预测值数组
    :param use_percentage: 是否使用百分比残差
    :return: sigma, residuals (list)
    """
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)

    # 避免除零
    safe_y_true = np.where(y_true == 0, 1e-8, y_true)

    if use_percentage:
        residuals = ((y_true - y_pred) / safe_y_true) * 100
    else:
        residuals = y_true - y_pred

    sigma = float(np.std(residuals))
    return sigma, residuals.tolist()


def aggregate_residuals(residuals, bin_size=100):
    """
    聚合残差数据以减少前端绘图量
    """
    agg_data = []
    n_bins = len(residuals) // bin_size
    for i in range(n_bins):
        segment = residuals[i*bin_size:(i+1)*bin_size]
        agg_data.append({
            "mean": float(np.mean(segment)),
            "std": float(np.std(segment)),
            "start": i*bin_size,
            "end": (i+1)*bin_size
        })
    return agg_data


# ===== 模拟数据 =====
samples = 5000
y_true = np.linspace(1, 100, samples)  # 避免为零
y_pred = y_true + np.random.normal(0, 5, samples)

# 计算绝对残差
sigma_abs, residuals_abs = calculate_residuals(y_true, y_pred, use_percentage=False)
agg_abs = aggregate_residuals(residuals_abs)

# 计算百分比残差
sigma_pct, residuals_pct = calculate_residuals(y_true, y_pred, use_percentage=True)
agg_pct = aggregate_residuals(residuals_pct)

# 输出给前端
result = {
    "absolute": {
        "sigma": sigma_abs,
        "residuals": residuals_abs,
        "aggregatedResiduals": agg_abs
    },
    "percentage": {
        "sigma": sigma_pct,
        "residuals": residuals_pct,
        "aggregatedResiduals": agg_pct
    }
}

print(result.keys())  # dict_keys(['absolute', 'percentage'])

import numpy as np

def calculate_sigma_bands(y_true, y_pred, use_percentage=False):
    y_true = np.array(y_true)
    y_pred = np.array(y_pred)
    safe_y_true = np.where(y_true == 0, 1e-8, y_true)

    residuals = ((y_true - y_pred) / safe_y_true) * 100 if use_percentage else (y_true - y_pred)
    sigma = np.std(residuals)

    # 计算1σ、2σ、3σ上下限
    bands = {
        "1sigma": {"upper": sigma, "lower": -sigma},
        "2sigma": {"upper": 2*sigma, "lower": -2*sigma},
        "3sigma": {"upper": 3*sigma, "lower": -3*sigma},
    }
    return residuals.tolist(), sigma, bands

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# 示例数据：真实值和预测值
np.random.seed(42)
y_true = np.random.uniform(50, 150, 1000)   # 真实值
y_pred = y_true + np.random.normal(0, 10, 1000)  # 预测值

# 计算百分比误差
percentage_error = np.abs(y_pred - y_true) / np.abs(y_true) * 100

# 绘制 Sigma 图函数
def plot_sigma_chart(errors, sigma_level=3, bins=20):
    """
    绘制 Sigma 图（带直方图和概率密度曲线）
    :param errors: 百分比误差数组
    :param sigma_level: sigma 范围（如3,4,5）
    :param bins: 直方图分箱数
    """
    # 计算均值和标准差
    mu, sigma = np.mean(errors), np.std(errors)
    
    # 直方图统计
    counts, bin_edges = np.histogram(errors, bins=bins, density=True)
    bin_centers = 0.5 * (bin_edges[1:] + bin_edges[:-1])
    
    # 高斯拟合曲线
    x = np.linspace(0, np.max(errors), 500)
    pdf = norm.pdf(x, mu, sigma)
    
    # 绘图
    plt.figure(figsize=(10, 6))
    plt.bar(bin_centers, counts, width=(bin_edges[1]-bin_edges[0]),
            alpha=0.6, color='skyblue', label='误差分布 (直方图)')
    plt.plot(x, pdf, 'r-', lw=2, label='正态拟合曲线')
    
    # 绘制 ±nσ 范围虚线
    for n in [-sigma_level, sigma_level]:
        plt.axvline(mu + n * sigma, color='green', linestyle='--', 
                    label=f'{n:+}σ 范围' if n > 0 else None)
    
    # 均值线
    plt.axvline(mu, color='black', linestyle='-', label='均值')
    
    # 标签和标题
    plt.xlabel('误差百分比 (%)')
    plt.ylabel('概率密度')
    plt.title(f'{sigma_level}-Sigma 图 (误差百分比分布)')
    plt.legend()
    plt.grid(True)
    plt.show()

# 绘制 3-Sigma 图
plot_sigma_chart(percentage_error, sigma_level=3, bins=20)

# 可切换为 4-Sigma、5-Sigma
# plot_sigma_chart(percentage_error, sigma_level=4, bins=20)
# plot_sigma_chart(percentage_error, sigma_level=5, bins=20)

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# 模拟数据（实际使用时替换为真实数据）
np.random.seed(42)
actual = np.random.uniform(50, 150, 1000)  # 实际值
predicted = actual + np.random.normal(0, 10, 1000)  # 预测值

# 计算相对误差百分比（可正可负）
relative_error_percent = (predicted - actual) / actual * 100

# 统计直方图数据
num_bins = 20  # 直方图柱数，可调整
counts, bin_edges = np.histogram(relative_error_percent, bins=num_bins, density=True)

# 计算每个柱的中心
bin_centers = 0.5 * (bin_edges[:-1] + bin_edges[1:])

# 估计误差分布的均值和标准差
mu, sigma = np.mean(relative_error_percent), np.std(relative_error_percent)

# 生成正态分布曲线
x = np.linspace(min(relative_error_percent), max(relative_error_percent), 500)
pdf = norm.pdf(x, mu, sigma)

# 绘图
plt.figure(figsize=(10, 6))

# 绘制直方图
plt.bar(bin_centers, counts, width=bin_edges[1]-bin_edges[0], alpha=0.6, color='skyblue', edgecolor='black', label='误差分布')

# 绘制正态分布曲线
plt.plot(x, pdf, 'r-', lw=2, label=f'正态分布拟合\nμ={mu:.2f}%, σ={sigma:.2f}%')

# 绘制多级sigma虚线
for s in [1, 2, 3, 4, 5]:  # 可自行调整sigma级数
    left, right = mu - s * sigma, mu + s * sigma
    plt.axvline(left, color='gray', linestyle='--', linewidth=1)
    plt.axvline(right, color='gray', linestyle='--', linewidth=1)
    plt.text(right, max(counts)*0.9, f'{s}σ', rotation=90, verticalalignment='top')

# 添加标签和图例
plt.xlabel('预测误差百分比 (%)')
plt.ylabel('概率密度')
plt.title('预测误差分布及多σ区间')
plt.legend()
plt.grid(alpha=0.3)
plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt

def plot_sigma_chart(x, y, sigma_level=3):
    """
    使用已有的 x 和 y 数据绘制 sigma 控制图。
    
    参数:
        x: 自变量数据 (列表或 NumPy 数组)
        y: 因变量数据 (列表或 NumPy 数组)
        sigma_level: sigma 水平（如 3 表示 3σ，4 表示 4σ）
    """
    # 转换为 NumPy 数组以便计算
    x = np.array(x)
    y = np.array(y)

    # 计算均值和标准差
    mean_y = np.mean(y)
    std_y = np.std(y)

    # 计算上限线和下限线
    upper_limit = mean_y + sigma_level * std_y
    lower_limit = mean_y - sigma_level * std_y

    # 开始绘图
    plt.figure(figsize=(10, 6))
    plt.plot(x, y, 'bo-', label='Data')  # 数据点

    # 绘制均值线
    plt.axhline(y=mean_y, color='green', linestyle='-', linewidth=2, label='Mean')

    # 绘制上限线和下限线
    plt.axhline(y=upper_limit, color='red', linestyle='--', linewidth=1.5, label=f'+{sigma_level}σ')
    plt.axhline(y=lower_limit, color='red', linestyle='--', linewidth=1.5, label=f'-{sigma_level}σ')

    # 标题和标签
    plt.title(f'Sigma Chart ({sigma_level}σ)')
    plt.xlabel('X')
    plt.ylabel('Y')
    plt.legend()
    plt.grid(True)
    plt.show()

# 示例：假设你已有训练数据 x 和 y
x = np.arange(1, 21)  # 训练数据的索引
y = np.random.normal(loc=50, scale=5, size=20)  # 模拟符合正态分布的训练结果

# 绘制 3σ 控制图
plot_sigma_chart(x, y, sigma_level=3)

# 可以修改 sigma_level 参数来绘制 4σ 或 5σ
# plot_sigma_chart(x, y, sigma_level=4)
# plot_sigma_chart(x, y, sigma_level=5)

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# ========== 数据准备 ==========
np.random.seed(42)
X = np.linspace(0, 10, 100).reshape(-1, 1)  # 特征
y = 3 * X.flatten() + 5 + np.random.normal(0, 2, 100)  # 线性关系 + 噪声

# 切分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# ========== 训练线性回归模型 ==========
model = LinearRegression()
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)

# ========== 计算残差 ==========
residuals = y_test - y_pred
mean_residual = np.mean(residuals)
std_residual = np.std(residuals)

# ========== 可调参数：sigma 范围 ==========
sigma_level = 3  # 可改为 4、5 等

# 计算控制限
upper_limit = mean_residual + sigma_level * std_residual
lower_limit = mean_residual - sigma_level * std_residual

# ========== 绘制 N-Sigma 控制图 ==========
plt.figure(figsize=(10, 6))
plt.plot(residuals, marker='o', linestyle='-', label='Residuals')
plt.axhline(mean_residual, color='green', linestyle='--', label='Mean')
plt.axhline(upper_limit, color='red', linestyle='--', label=f'+{sigma_level}σ')
plt.axhline(lower_limit, color='red', linestyle='--', label=f'-{sigma_level}σ')

# 标记超出 Nσ 的点
outliers = np.where((residuals > upper_limit) | (residuals < lower_limit))[0]
plt.scatter(outliers, residuals[outliers], color='red', s=80, edgecolors='black', label='Outliers')

plt.title(f'{sigma_level}-Sigma Control Chart for Regression Residuals')
plt.xlabel('Sample Index')
plt.ylabel('Residual')
plt.legend()
plt.grid(True)
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# ================================
# 1. 生成示例数据（线性回归残差）
# ================================
np.random.seed(42)
# 假设真实误差为正态分布 N(0, 0.1)
errors = np.random.normal(loc=0, scale=0.1, size=1000)

# 转换为绝对差值百分比 (例如预测值的 1 为基准)
abs_errors_pct = np.abs(errors) * 100

# ================================
# 2. 计算均值和标准差
# ================================
mean = np.mean(abs_errors_pct)
std = np.std(abs_errors_pct)

# ================================
# 3. 绘制直方图 + 累积分布曲线
# ================================
plt.figure(figsize=(10, 6))

# --- 直方图 ---
counts, bins, patches = plt.hist(
    abs_errors_pct, bins=20, density=True, alpha=0.6, color='skyblue', label='误差直方图'
)

# --- 计算正态分布拟合曲线 ---
x = np.linspace(0, max(abs_errors_pct) * 1.1, 500)
pdf = norm.pdf(x, mean, std)  # 概率密度函数
cdf = norm.cdf(x, mean, std)  # 累积分布函数 (σ线)

# --- 绘制概率密度曲线 ---
plt.plot(x, pdf, 'r-', lw=2, label='正态分布曲线')

# --- 绘制累积分布曲线 ---
plt.plot(x, cdf, 'g-', lw=2, label='累积分布曲线 (σ)')

# ================================
# 4. 绘制 1σ、2σ、3σ 虚线
# ================================
for i in range(1, 4):
    plt.axvline(mean + i * std, color='gray', linestyle='--', lw=1)
    plt.axvline(max(0, mean - i * std), color='gray', linestyle='--', lw=1)
    plt.text(mean + i * std, max(pdf)*0.8, f'+{i}σ', rotation=90)
    plt.text(max(0, mean - i * std), max(pdf)*0.8, f'-{i}σ', rotation=90)

# ================================
# 5. 图形美化
# ================================
plt.title('3-Sigma 误差分布图')
plt.xlabel('绝对差值百分比 (%)')
plt.ylabel('概率密度 / 累积分布')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.5)
plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

def plot_residuals_distribution(
    residuals,
    bins=30,
    show_fit=True,
    show_cdf=False,
    title="Residuals Distribution with 3σ Rule"
):
    """
    绘制残差分布图，包含 3σ 区间，可选正态拟合曲线和CDF曲线。

    参数：
        residuals (array-like): 残差数据
        bins (int): 直方图的柱数
        show_fit (bool): 是否显示正态分布拟合曲线
        show_cdf (bool): 是否显示累积分布曲线
        title (str): 图表标题
    """
    residuals = np.array(residuals)
    mean = np.mean(residuals)
    std = np.std(residuals)

    # 绘制直方图
    fig, ax1 = plt.subplots(figsize=(8, 5))
    n, bins_hist, patches = ax1.hist(residuals, bins=bins, density=True, alpha=0.6, color='skyblue')

    # 绘制正态拟合曲线
    if show_fit:
        x = np.linspace(min(residuals), max(residuals), 200)
        y = norm.pdf(x, mean, std)
        ax1.plot(x, y, 'r-', lw=2, label="Normal Fit")

    # 标记 1σ、2σ、3σ 区间
    for i, color in zip([1, 2, 3], ['g', 'orange', 'r']):
        ax1.axvline(mean + i*std, color=color, linestyle='--', label=f'+{i}σ')
        ax1.axvline(mean - i*std, color=color, linestyle='--', label=f'-{i}σ')

    ax1.set_title(title)
    ax1.set_xlabel("Residual")
    ax1.set_ylabel("Density")
    ax1.legend()

    # 可选：绘制累积分布曲线
    if show_cdf:
        ax2 = ax1.twinx()
        sorted_res = np.sort(residuals)
        cdf = np.arange(1, len(residuals)+1) / len(residuals)
        ax2.plot(sorted_res, cdf, 'k-', lw=1.5, label='CDF')
        ax2.set_ylabel("CDF")
        ax2.legend(loc='lower right')

    plt.show()

# 示例残差数据
residuals = np.random.normal(0, 2, 1000)

# 仅绘制直方图+拟合曲线+3σ
plot_residuals_distribution(residuals)

# 绘制直方图+拟合曲线+CDF
plot_residuals_distribution(residuals, show_cdf=True)

import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import norm

# 示例数据
np.random.seed(42)
actual = np.random.normal(100, 10, 1000)  # 实际值
predicted = actual + np.random.normal(0, 5, 1000)  # 预测值

# 计算差值百分比 (不取绝对值)
diff_percentage = (predicted - actual) / actual * 100

# 绘制 sigma 图函数
def plot_sigma_hist(diff_percentage, bins=20, sigma_level=3):
    """
    绘制包含直方图和 sigma 线的图像
    :param diff_percentage: 差值百分比数组
    :param bins: 直方图分箱数
    :param sigma_level: sigma 范围（例如 3 表示 ±3σ）
    """
    mean = np.mean(diff_percentage)
    std = np.std(diff_percentage)

    # 绘制直方图，density=True 使 y 轴为概率密度
    counts, bin_edges, _ = plt.hist(diff_percentage, bins=bins, density=True,
                                    alpha=0.6, color='skyblue', edgecolor='black',
                                    label='差值百分比直方图')

    # 生成平滑的 x 轴数据用于绘制正态分布曲线
    x = np.linspace(min(diff_percentage), max(diff_percentage), 1000)
    pdf = norm.pdf(x, mean, std)  # 正态分布概率密度函数

    plt.plot(x, pdf, 'r-', linewidth=2, label='正态分布拟合曲线')

    # 绘制 sigma 虚线
    for i in range(1, sigma_level + 1):
        lower = mean - i * std
        upper = mean + i * std
        plt.axvline(lower, color='gray', linestyle='--', linewidth=1)
        plt.axvline(upper, color='gray', linestyle='--', linewidth=1)
        plt.text(upper, max(pdf) * 0.9, f'+{i}σ', rotation=0, fontsize=8)
        plt.text(lower, max(pdf) * 0.9, f'-{i}σ', rotation=0, fontsize=8)

    plt.xlabel("差值百分比 (%)")
    plt.ylabel("概率密度")
    plt.title(f"差值百分比直方图及 ±{sigma_level}σ 范围")
    plt.legend()
    plt.grid(alpha=0.3)
    plt.show()

# 调用函数
plot_sigma_hist(diff_percentage, bins=20, sigma_level=4)

import numpy as np
import json

# 生成示例数据
np.random.seed(42)
actual = np.random.normal(100, 10, 500)  # 实际值
predicted = actual + np.random.normal(0, 5, 500)  # 预测值

# 计算差值百分比 (不取绝对值)
diff_percent = (predicted - actual) / actual * 100  # 差值百分比

# 计算直方图数据
num_bins = 20
counts, bin_edges = np.histogram(diff_percent, bins=num_bins, density=True)

# 转换为 ECharts 所需的格式 (柱状图数据)
bar_data = [{"value": round(c, 6), "bin": f"{round(bin_edges[i],2)}~{round(bin_edges[i+1],2)}"} 
            for i, c in enumerate(counts)]

# 生成 x 轴坐标（使用每个区间的中点）
x_data = [(bin_edges[i] + bin_edges[i+1]) / 2 for i in range(len(bin_edges)-1)]

# 计算 sigma 线条
sigma_levels = [1, 2, 3, 4, 5]  # 可动态选择
mean = np.mean(diff_percent)
std = np.std(diff_percent)

sigma_lines = {}
for s in sigma_levels:
    # 理论正态分布曲线
    x_line = np.linspace(mean - s * std, mean + s * std, 200)
    y_line = (1/(std*np.sqrt(2*np.pi))) * np.exp(-0.5*((x_line-mean)/std)**2)
    sigma_lines[s] = {"x": x_line.tolist(), "y": y_line.tolist()}

# 导出为 JSON 供前端使用
chart_data = {
    "x_data": [round(x, 3) for x in x_data],
    "bar_data": [round(c, 6) for c in counts],
    "sigma_lines": sigma_lines
}

with open("chart_data.json", "w") as f:
    json.dump(chart_data, f, indent=2)

import numpy as np
import json
from scipy.stats import norm

# 模拟数据
np.random.seed(42)
actual = np.random.normal(100, 10, 500)
predicted = actual + np.random.normal(0, 5, 500)

# 差值百分比
diff_percent = (predicted - actual) / actual * 100

# 统计直方图数据
num_bins = 20
counts, bin_edges = np.histogram(diff_percent, bins=num_bins, density=True)
x_data = [(bin_edges[i] + bin_edges[i+1]) / 2 for i in range(len(bin_edges)-1)]

# 正态分布拟合
mean = np.mean(diff_percent)
std = np.std(diff_percent)
x_line = np.linspace(mean - 4*std, mean + 4*std, 200)
y_line = norm.pdf(x_line, mean, std)

# Sigma 区间概率
sigma_levels = [1, 2, 3, 4, 5]
sigma_lines = []
sigma_probs = []
for s in sigma_levels:
    left = mean - s * std
    right = mean + s * std
    prob = norm.cdf(right, mean, std) - norm.cdf(left, mean, std)
    sigma_lines.append(left)
    sigma_lines.append(right)
    sigma_probs.append({"sigma": s, "probability": round(prob, 4)})

chart_data = {
    "x_data": [round(x, 3) for x in x_data],
    "bar_data": [round(c, 6) for c in counts],
    "curve": {"x": x_line.tolist(), "y": y_line.tolist()},
    "sigma_lines": sigma_lines,
    "sigma_probs": sigma_probs
}

with open("chart_data.json", "w") as f:
    json.dump(chart_data, f, indent=2)

import numpy as np
import json

def generate_sigma_data(mean, std, size=10000, max_points=800):
    x = np.linspace(mean - 4*std, mean + 4*std, size)
    y = 1/(std * np.sqrt(2*np.pi)) * np.exp(-0.5*((x-mean)/std)**2)
    
    # 分桶采样
    if size > max_points:
        step = size // max_points
        x = x[::step]
        y = y[::step]
    
    data = [{"x": float(xi), "y": float(yi)} for xi, yi in zip(x, y)]
    return json.dumps(data, ensure_ascii=False)

print(generate_sigma_data(0, 1, size=50000))