seaborn 绘制tensorboard奖励的平均值、标准差阴影图

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

from scipy.ndimage import gaussian_filter1d
sns.set()



# def smooth(data, wd=2):
#     """
#     :param data: ndarray，一维或二维
#     :param wd:
#     :return:
#     """
#     if not (isinstance(wd, int) and wd > 0):
#         raise ValueError('wd must be a positive integer')
#     elif 1 == wd:
#         return data
#     else:
#         weight = np.ones(wd) / wd
#         if 1 == data.ndim:
#             return np.convolve(weight, data, "same")
#         elif 2 == data.ndim:
#             smooth_data = []
#             for d in data:
#                 d = np.convolve(weight, d, "same")
#                 smooth_data.append(d)
#             return np.array(smooth_data)
#         else:
#             raise ValueError('data must be a one-dimensional or two-dimensional ndarray')



# sigma 越大 拟合的越平滑
def smooth(data, wd=2, method='gaussian', sigma=5):
    """
    :param data: ndarray, 一维或二维
    :param wd: 窗口宽度，用于移动平均
    :param method: 平滑方法，可选 'moving_average' 或 'gaussian'
    :param sigma: 高斯平滑的标准差，仅在 method='gaussian' 时有效
    :return: 平滑后的数据
    """
    if not (isinstance(wd, int) and wd > 0):
        raise ValueError('wd must be a positive integer')

    if method == 'moving_average':
        if wd == 1:
            return data
        else:
            weight = np.ones(wd) / wd
            if data.ndim == 1:
                return np.convolve(weight, data, "same")
            elif data.ndim == 2:
                smooth_data = [np.convolve(weight, d, "same") for d in data]
                return np.array(smooth_data)
            else:
                raise ValueError('data must be a one-dimensional or two-dimensional ndarray')

    elif method == 'gaussian':
        if data.ndim == 1:
            return gaussian_filter1d(data, sigma=sigma)
        elif data.ndim == 2:
            smooth_data = [gaussian_filter1d(d, sigma=sigma) for d in data]
            return np.array(smooth_data)
        else:
            raise ValueError('data must be a one-dimensional or two-dimensional ndarray')

    else:
        raise ValueError('Invalid method. Choose "moving_average" or "gaussian".')


def get_data():
    vT1 = pd.read_csv("v3num6_evaderTarget.csv")
    vT2 = pd.read_csv("v4num6_evaderTarget.csv")
    vA1 = pd.read_csv("v3num6_Pursuer.csv")
    vA2 = pd.read_csv("v4num6_Pursuer.csv")

    vT1_array = vT1['Value']
    vT2_array = vT2['Value']
    vA1_array = vA1['Value']
    vA2_array = vA2['Value']
    # Stack the arrays vertically to create a 3 x length(v1) array
    returns1 = np.vstack((vA1_array, vA2_array))
    returns1 = smooth(returns1, 2)
    returns2 = np.vstack((vT1_array, vT2_array))
    returns2 = smooth(returns2, 2)

    return returns1, returns2


np.random.seed(11)
data = get_data()
label = ['Attacker', 'Target']

df=[]
vT1 = pd.read_csv("v3num6_evaderTarget.csv")
ax = vT1['Step']  # x轴刻度

for i in range(len(data)):
    df.append(pd.DataFrame(data[i], columns=ax).melt(var_name='episode',value_name='return'))
    df[i]['algo'] = label[i]
df = pd.concat(df, ignore_index=True)
# print(df)
sns.lineplot(x="episode", y="return", hue="algo", data=df)
plt.legend(loc='upper right')
# 'best', 'upper right', 'upper left', 'lower left', 'lower right',
#             'right', 'center left', 'center , right', 'lower center', 'upper center', 'center')

plt.title("")
plt.show()