随机生成三类数据,每类20个样本,样本为二维向量,不使用sklearn的条件下利用交叉熵计算损失构建一个隐藏层为4的BP神经网络进行分类并可视化

好的，我可以帮你解决这个问题。首先，我们可以使用Python的NumPy库来生成三类20个样本的二维向量数据。具体代码如下：

import numpy as np

# 生成三类20个样本的二维向量数据
np.random.seed(42)
class_1 = np.random.normal(loc=[-2, 2], scale=[0.5, 0.5], size=(20, 2))
class_2 = np.random.normal(loc=[2, 2], scale=[0.5, 0.5], size=(20, 2))
class_3 = np.random.normal(loc=[0, -2], scale=[0.5, 0.5], size=(20, 2))

# 将三类数据合并成一个数据集
X = np.vstack((class_1, class_2, class_3))
y = np.array([0] * 20 + [1] * 20 + [2] * 20)

接着，我们可以定义一个隐藏层为4的BP神经网络，并使用交叉熵作为损失函数进行训练。代码如下：

class NeuralNetwork:
    def __init__(self, input_dim, hidden_dim, output_dim):
        self.input_dim = input_dim
        self.hidden_dim = hidden_dim
        self.output_dim = output_dim
        self.W1 = np.random.randn(input_dim, hidden_dim)
        self.b1 = np.zeros((1, hidden_dim))
        self.W2 = np.random.randn(hidden_dim, output_dim)
        self.b2 = np.zeros((1, output_dim))

    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def softmax(self, x):
        exp_scores = np.exp(x)
        return exp_scores / np.sum(exp_scores, axis=1, keepdims=True)

    def forward(self, 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.probs = self.softmax(self.z2)

    def backward(self, X, y, learning_rate):
        delta3 = self.probs
        delta3[range(len(X)), y] -= 1
        dW2 = np.dot(self.a1.T, delta3)
        db2 = np.sum(delta3, axis=0, keepdims=True)
        delta2 = np.dot(delta3, self.W2.T) * self.a1 * (1 - self.a1)
        dW1 = np.dot(X.T, delta2)
        db1 = np.sum(delta2, axis=0)
        self.W1 -= learning_rate * dW1
        self.b1 -= learning_rate * db1
        self.W2 -= learning_rate * dW2
        self.b2 -= learning_rate * db2

    def predict(self, X):
        self.forward(X)
        return np.argmax(self.probs, axis=1)
    
    def fit(self, X, y, num_epochs, learning_rate):
        for i in range(num_epochs):
            self.forward(X)
            loss = -np.log(self.probs[range(len(X)), y]).mean()
            if i % 1000 == 0:
                print(f"Epoch {i}: loss {loss}")
            self.backward(X, y, learning_rate)

最后，我们可以使用Matplotlib库将分类结果可视化。代码如下：

import matplotlib.pyplot as plt

# 训练神经网络并预测结果
nn = NeuralNetwork(input_dim=2, hidden_dim=4, output_dim=3)
nn.fit(X, y, num_epochs=5000, learning_rate=0.1)
y_pred = nn.predict(X)

# 将数据可视化
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap=plt.cm.get_cmap('viridis', 3))
plt.colorbar(ticks=range(3))
plt.show()

运行代码后，你将得到一个可视化的散点图，其中三类数据被不同的颜色区分开来，如下图所示：