python计算两个曲线的拟合度R2，不用sklearn库

若不使用`sklearn`库，你可以使用`numpy`库来计算两个曲线的拟合度R^2。以下是一个示例代码：

import numpy as np

# 两个曲线的数据点
y_true = np.array([1, 2, 3, 4, 5])
y_pred = np.array([1.2, 2.3, 2.8, 4.1, 5.2])

# 计算拟合度R^2
mean_y_true = np.mean(y_true)
ss_total = np.sum((y_true - mean_y_true)**2)
ss_residual = np.sum((y_true - y_pred)**2)
r2 = 1 - (ss_residual / ss_total)

print("R^2:", r2)

在上述代码中，`y_true`是真实的数据点，`y_pred`是预测的数据点。你需要将其替换为你实际的数据。代码通过计算总平方和（`ss_total`）和残差平方和（`ss_residual`），然后根据公式 R^2 = 1 - (ss_residual / ss_total) 计算得到拟合度R^2的值。

运行上述代码后，将输出拟合度R^2的值。

请注意，R^2 取值范围是 [0, 1]，越接近1表示拟合度越好。

希望对你有所帮助！如有任何问题，请随时提问。

相关问题

python计算两个曲线的拟合度R2

在 Python 中，你可以使用 `sklearn.metrics` 模块中的 `r2_score` 函数来计算两个曲线的拟合度 R^2。以下是一个示例代码：

from sklearn.metrics import r2_score
import numpy as np

# 两个曲线的数据点
y_true = np.array([1, 2, 3, 4, 5])
y_pred = np.array([1.2, 2.3, 2.8, 4.1, 5.2])

# 计算 R^2
r2 = r2_score(y_true, y_pred)

print("R^2:", r2)

在上述代码中，`y_true` 是真实的数据点，`y_pred` 是预测的数据点。你需要将其替换为你实际的数据。代码通过调用 `r2_score` 函数并传递真实数据和预测数据作为参数，计算得到 R^2 值。

运行上述代码后，将会输出 R^2 值。

请注意，R^2 取值范围是 [0, 1]，越接近 1 表示拟合度越好。

希望对你有所帮助！如果还有其他问题，请随时提问。

使用python创建一个使用归一化、Xavier初始化、正则化方法和MSGD的BP网络，该网络有8个输入1个输出1层隐藏层，要求分为两个模块（py文件），在确认输入、输出的训练集之后，模型不会出现shape类报错，且一个是BP网络，另一个是主函数，尝试在main模块中实现绘制R2图来说明模型的拟合度，并且输出MAE、MSE、预测值和真实值之间的相对误差平均百分比，绘制各输入输出的拟合折线图，且R2图和折线图中使用的数据均为未变换数据，在每句代码后添加注释；练集数据存于xlsx表格前3000行中，之后的都是测试集，且均为float类型。并且能够输出各输入的权重。

为了实现你的需求，我们需要创建两个模块：一个是BP网络的模块，另一个是主函数模块。下面是BP网络模块的代码（命名为bp_network.py）：

import numpy as np
import pandas as pd

class BPNetwork:
    def __init__(self, input_dim, hidden_dim, output_dim):
        """
        初始化BP网络
        :param input_dim: 输入层维数
        :param hidden_dim: 隐藏层维数
        :param output_dim: 输出层维数
        """
        # 初始化权重和偏置
        self.w1 = np.random.randn(input_dim, hidden_dim) * np.sqrt(2 / (input_dim + hidden_dim))  # Xavier初始化
        self.b1 = np.zeros(hidden_dim)
        self.w2 = np.random.randn(hidden_dim, output_dim) * np.sqrt(2 / (hidden_dim + output_dim))  # Xavier初始化
        self.b2 = np.zeros(output_dim)
        
    def sigmoid(self, x):
        """
        激活函数：sigmoid
        """
        return 1 / (1 + np.exp(-x))
    
    def sigmoid_deriv(self, x):
        """
        激活函数sigmoid的导数
        """
        return self.sigmoid(x) * (1 - self.sigmoid(x))
    
    def l2_regularization(self, lambd, w1, w2):
        """
        L2正则化
        """
        return (lambd/2) * (np.sum(w1**2) + np.sum(w2**2))
    
    def forward(self, X):
        """
        前向传播
        :param X: 输入数据
        """
        self.z1 = np.dot(X, self.w1) + self.b1  # 第一层线性加权和
        self.a1 = self.sigmoid(self.z1)  # 第一层激活输出
        self.z2 = np.dot(self.a1, self.w2) + self.b2  # 第二层线性加权和
        self.a2 = self.sigmoid(self.z2)  # 第二层激活输出
        return self.a2
    
    def backward(self, X, y, learning_rate, lambd):
        """
        反向传播
        :param X: 输入数据
        :param y: 真实输出数据
        :param learning_rate: 学习率
        :param lambd: 正则化参数
        """
        # 计算输出层误差
        delta2 = (self.a2 - y) * self.sigmoid_deriv(self.z2)
        # 计算输出层权重和偏置的梯度
        dw2 = np.dot(self.a1.T, delta2) + lambd * self.w2
        db2 = np.sum(delta2, axis=0)
        # 计算隐藏层误差
        delta1 = np.dot(delta2, self.w2.T) * self.sigmoid_deriv(self.z1)
        # 计算隐藏层权重和偏置的梯度
        dw1 = np.dot(X.T, delta1) + lambd * self.w1
        db1 = np.sum(delta1, axis=0)
        # 更新权重和偏置
        self.w1 -= learning_rate * dw1
        self.b1 -= learning_rate * db1
        self.w2 -= learning_rate * dw2
        self.b2 -= learning_rate * db2
        
    def train(self, X_train, y_train, X_val, y_val, epochs, learning_rate, lambd):
        """
        训练BP网络
        :param X_train: 训练数据
        :param y_train: 训练标签
        :param X_val: 验证数据
        :param y_val: 验证标签
        :param epochs: 迭代次数
        :param learning_rate: 学习率
        :param lambd: 正则化参数
        """
        train_losses = []
        val_losses = []
        
        for i in range(epochs):
            # 前向传播
            y_pred_train = self.forward(X_train)
            y_pred_val = self.forward(X_val)
            # 计算损失函数值
            train_loss = np.mean((y_pred_train - y_train) ** 2) + self.l2_regularization(lambd, self.w1, self.w2)
            val_loss = np.mean((y_pred_val - y_val) ** 2) + self.l2_regularization(lambd, self.w1, self.w2)
            train_losses.append(train_loss)
            val_losses.append(val_loss)
            # 反向传播
            self.backward(X_train, y_train, learning_rate, lambd)
            
            if i % 100 == 0:
                print(f"Epoch {i}, Train Loss: {train_loss:.4f}, Validation Loss: {val_loss:.4f}")
                
        return train_losses, val_losses
    
    def predict(self, X_test):
        """
        预测
        :param X_test: 测试数据
        """
        y_pred = self.forward(X_test)
        return y_pred
    
    def get_weights(self):
        """
        获取权重
        """
        return self.w1, self.w2

下面是主函数模块的代码（命名为main.py）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler

from bp_network import BPNetwork  # 导入BP网络模块

# 读取数据
data = pd.read_excel("data.xlsx", nrows=3000)  # 只读取前3000行作为训练集

# 数据预处理
scaler = MinMaxScaler()  # 创建归一化器
X_train = data.iloc[:, :8].values.astype(float)  # 取前8列作为输入数据，转换为float类型
y_train = data.iloc[:, -1].values.reshape(-1, 1).astype(float)  # 取最后一列作为输出数据，转换为float类型
X_train_norm = scaler.fit_transform(X_train)  # 对输入数据进行归一化处理
y_train_norm = scaler.fit_transform(y_train)  # 对输出数据进行归一化处理

# 创建BP网络模型
input_dim = 8  # 输入层维数
hidden_dim = 4  # 隐藏层维数
output_dim = 1  # 输出层维数
bpnet = BPNetwork(input_dim, hidden_dim, output_dim)

# 训练BP网络模型
epochs = 10000  # 迭代次数
learning_rate = 0.1  # 学习率
lambd = 0.01  # 正则化参数
train_losses, val_losses = bpnet.train(X_train_norm, y_train_norm, X_train_norm, y_train_norm, epochs, learning_rate, lambd)

# 绘制训练和验证损失函数曲线
plt.plot(train_losses, label="Train Loss")
plt.plot(val_losses, label="Validation Loss")
plt.legend()
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.show()

# 计算拟合度R2和相对误差平均百分比
y_pred_norm = bpnet.predict(X_train_norm)  # 预测归一化后的输出数据
y_pred = scaler.inverse_transform(y_pred_norm)  # 将预测结果反归一化
r2 = 1 - np.sum((y_train - y_pred) ** 2) / np.sum((y_train - np.mean(y_train)) ** 2)  # 计算拟合度R2
mae = np.mean(np.abs(y_train - y_pred))  # 计算MAE
mse = np.mean((y_train - y_pred) ** 2)  # 计算MSE
relative_error = np.mean(np.abs((y_train - y_pred) / y_train)) * 100  # 计算相对误差平均百分比
print(f"R2: {r2:.4f}")
print(f"MAE: {mae:.4f}")
print(f"MSE: {mse:.4f}")
print(f"Relative Error: {relative_error:.2f}%")

# 绘制各输入输出的拟合折线图
for i in range(input_dim):
    plt.scatter(X_train[:, i], y_train, label="True")
    plt.scatter(X_train[:, i], y_pred, label="Predicted")
    plt.legend()
    plt.xlabel(f"Input {i+1}")
    plt.ylabel("Output")
    plt.show()

# 输出各输入的权重
w1, w2 = bpnet.get_weights()
for i in range(input_dim):
    print(f"Input {i+1} Weight: {w1[i]}")

在运行主函数模块（main.py）之前，需要确保以下几点：

1. 在命令行执行 `pip install pandas matplotlib scikit-learn` 安装必要的包。
2. 将数据存储在名为 `data.xlsx` 的 Excel 文件中。注意，该文件只存储了前3000个样本作为训练集，之后的样本可用于测试集。

运行主函数模块时，将会输出训练过程中的损失函数曲线、拟合度R2、MAE、MSE、相对误差平均百分比等信息，并绘制各输入输出的拟合折线图。同时，还会输出各输入的权重。