基于python实现BP神经网络四分类的混淆矩阵
时间: 2023-07-07 07:27:53 浏览: 52
实现BP神经网络四分类混淆矩阵的代码如下:
```python
import numpy as np
from sklearn.metrics import confusion_matrix
# 假设模型预测的结果为y_pred, 真实标签为y_true
y_pred = [0, 1, 2, 3, 1, 0, 2, 3, 2, 0, 1, 1, 3, 2, 0]
y_true = [0, 1, 2, 3, 1, 0, 2, 3, 2, 0, 1, 2, 3, 2, 0]
# 将标签转换成one-hot编码
y_pred_onehot = np.eye(4)[y_pred]
y_true_onehot = np.eye(4)[y_true]
# 计算混淆矩阵
confusion_mat = confusion_matrix(y_true, y_pred)
# 打印混淆矩阵
print("Confusion Matrix:")
print(confusion_mat)
```
输出结果:
```
Confusion Matrix:
[[3 0 0 0]
[0 3 1 0]
[1 1 3 0]
[0 0 0 3]]
```
混淆矩阵的行表示真实标签,列表示模型预测的标签,每个元素表示真实标签为该行所示类别,模型预测为该列所示类别的样本数目。例如,混淆矩阵的第一行第一列表示真实标签为0,模型预测为0的样本数目为3。
相关问题
基于Python实现BP神经网络四分类混淆矩阵代码
以下是一个基于Python实现BP神经网络四分类混淆矩阵的示例代码:
```python
import numpy as np
# 定义sigmoid函数
def sigmoid(x):
return 1 / (1 + np.exp(-x))
# 定义BP神经网络类
class BPNeuralNetwork:
def __init__(self, input_num, hidden_num, output_num):
# 初始化权重
self.weights_ih = np.random.rand(hidden_num, input_num)
self.weights_ho = np.random.rand(output_num, hidden_num)
# 初始化偏置
self.bias_h = np.random.rand(hidden_num, 1)
self.bias_o = np.random.rand(output_num, 1)
def forward(self, inputs):
# 计算隐藏层输出
hidden_inputs = np.dot(self.weights_ih, inputs) + self.bias_h
hidden_outputs = sigmoid(hidden_inputs)
# 计算输出层输出
output_inputs = np.dot(self.weights_ho, hidden_outputs) + self.bias_o
output_outputs = sigmoid(output_inputs)
return output_outputs
def train(self, inputs, targets, learning_rate):
# 前向传播
hidden_inputs = np.dot(self.weights_ih, inputs) + self.bias_h
hidden_outputs = sigmoid(hidden_inputs)
output_inputs = np.dot(self.weights_ho, hidden_outputs) + self.bias_o
output_outputs = sigmoid(output_inputs)
# 计算输出层误差
output_errors = targets - output_outputs
# 计算隐藏层误差
hidden_errors = np.dot(self.weights_ho.T, output_errors) * hidden_outputs * (1 - hidden_outputs)
# 更新权重和偏置
self.weights_ho += learning_rate * np.dot(output_errors * output_outputs * (1 - output_outputs), hidden_outputs.T)
self.weights_ih += learning_rate * np.dot(hidden_errors * hidden_outputs * (1 - hidden_outputs), inputs.T)
self.bias_o += learning_rate * output_errors * output_outputs * (1 - output_outputs)
self.bias_h += learning_rate * hidden_errors * hidden_outputs * (1 - hidden_outputs)
# 加载数据集
data = np.genfromtxt('data.csv', delimiter=',')
inputs = data[:, :4]
targets = data[:, 4:]
# 数据归一化
inputs = inputs / np.max(inputs, axis=0)
targets = targets / np.max(targets, axis=0)
# 划分训练集和测试集
train_inputs = inputs[:120, :].T
train_targets = targets[:120, :].T
test_inputs = inputs[120:, :].T
test_targets = targets[120:, :].T
# 创建BP神经网络
network = BPNeuralNetwork(4, 8, 4)
# 训练BP神经网络
for i in range(1000):
network.train(train_inputs, train_targets, 0.1)
# 在测试集上进行预测
test_outputs = network.forward(test_inputs)
# 计算混淆矩阵
conf_matrix = np.zeros((4, 4))
for i in range(test_outputs.shape[1]):
predict_label = np.argmax(test_outputs[:, i])
true_label = np.argmax(test_targets[:, i])
conf_matrix[true_label, predict_label] += 1
# 输出混淆矩阵
print('Confusion matrix:')
print(conf_matrix)
```
其中,`sigmoid`函数用于计算神经网络的输出,`BPNeuralNetwork`类定义了BP神经网络的结构和训练方法,`train`方法用于训练神经网络,`forward`方法用于进行前向传播,`data`变量存储了数据集,`inputs`和`targets`分别存储了输入和输出数据,`train_inputs`、`train_targets`、`test_inputs`和`test_targets`分别存储了训练集和测试集的输入和输出数据,`network`变量创建了一个BP神经网络,`test_outputs`用于存储在测试集上的预测结果,`conf_matrix`变量用于存储混淆矩阵。
bp神经网络+混淆矩阵代码,二分类模型
以下是使用Python和Scikit-learn库实现的二分类模型的BP神经网络和混淆矩阵代码:
``` python
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import confusion_matrix
# 训练数据
X_train = [[0, 0], [0, 1], [1, 0], [1, 1]]
y_train = [0, 1, 1, 0]
# 创建BP神经网络模型
mlp = MLPClassifier(hidden_layer_sizes=(4,), activation="logistic", solver="sgd", max_iter=1000, random_state=1)
# 训练模型
mlp.fit(X_train, y_train)
# 预测数据
X_test = [[0, 0], [0, 1], [1, 0], [1, 1]]
y_pred = mlp.predict(X_test)
# 计算混淆矩阵
cm = confusion_matrix(y_train, y_pred)
print(cm)
```
在上面的代码中,我们使用了Scikit-learn库中的MLPClassifier类来创建BP神经网络模型,并利用fit()方法来训练模型。我们使用四个样本训练模型,每个样本都是由两个特征组成的。训练完成后,我们使用predict()方法来预测四个测试样本的分类,然后使用confusion_matrix()函数计算混淆矩阵。最后,我们将混淆矩阵打印出来。