用Python写一个用BP算法实现分类的代码，其中隐藏层的激励函数采用tanh函数，输出层的激励函数采用sigmoid函数，目标函数采用平方误差函数，输入层为三层，待分类数据由用户输入

好的，我可以为您提供一个简单的Python代码实现BP算法进行分类，如下所示：

import numpy as np

class BP_NeuralNetwork:
    def __init__(self, X, y, hidden_layers=2, hidden_units=3, learning_rate=0.1, epochs=1000):
        self.X = X
        self.y = y
        self.input_units = X.shape[1]
        self.hidden_layers = hidden_layers
        self.hidden_units = hidden_units
        self.output_units = y.shape[1]
        self.learning_rate = learning_rate
        self.epochs = epochs
        self.initialize_weights()

    def initialize_weights(self):
        self.weights = []
        input_hidden_weights = np.random.randn(self.input_units, self.hidden_units)
        self.weights.append(input_hidden_weights)
        for i in range(self.hidden_layers - 1):
            hidden_hidden_weights = np.random.randn(self.hidden_units, self.hidden_units)
            self.weights.append(hidden_hidden_weights)
        hidden_output_weights = np.random.randn(self.hidden_units, self.output_units)
        self.weights.append(hidden_output_weights)

    def tanh(self, x):
        return np.tanh(x)

    def tanh_derivative(self, x):
        return 1 - np.tanh(x)**2

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

    def sigmoid_derivative(self, x):
        return self.sigmoid(x) * (1 - self.sigmoid(x))

    def forward_propagation(self, X):
        self.a = []
        self.z = []
        a_i = X
        self.a.append(a_i)
        for i in range(self.hidden_layers):
            z_i = np.dot(a_i, self.weights[i])
            a_i = self.tanh(z_i)
            self.z.append(z_i)
            self.a.append(a_i)
        z_output = np.dot(a_i, self.weights[-1])
        a_output = self.sigmoid(z_output)
        self.z.append(z_output)
        self.a.append(a_output)
        return a_output

    def backward_propagation(self, X, y, output):
        delta = output - y
        delta_weights = []
        delta_weights.append(np.dot(self.a[-2].T, delta * self.sigmoid_derivative(self.z[-1])))
        for i in range(self.hidden_layers - 1, 0, -1):
            delta = np.dot(delta, self.weights[i+1].T) * self.tanh_derivative(self.z[i])
            delta_weights.insert(0, np.dot(self.a[i-1].T, delta))
        delta = np.dot(delta, self.weights[1].T) * self.tanh_derivative(self.z[0])
        delta_weights.insert(0, np.dot(X.T, delta))
        return delta_weights

    def update_weights(self, delta_weights):
        for i in range(len(self.weights)):
            self.weights[i] -= self.learning_rate * delta_weights[i]

    def train(self):
        for i in range(self.epochs):
            output = self.forward_propagation(self.X)
            delta_weights = self.backward_propagation(self.X, self.y, output)
            self.update_weights(delta_weights)

    def predict(self, X):
        output = self.forward_propagation(X)
        predictions = np.round(output)
        return predictions

该代码实现了一个三层BP神经网络，其中包含一个隐藏层和一个输出层。使用tanh函数作为隐藏层的激励函数，sigmoid函数作为输出层的激励函数，平方误差函数作为目标函数。训练数据包括输入X和输出y，可以使用train()函数进行训练，使用predict()函数进行预测。

以下是一个示例，展示如何使用该代码对用户输入的待分类数据进行分类：

# 生成随机数据，用于演示
X = np.random.randn(100, 3)
y = np.random.randint(0, 2, (100, 1))

# 创建BP神经网络对象
model = BP_NeuralNetwork(X, y, hidden_layers=1, hidden_units=5, learning_rate=0.1, epochs=1000)

# 训练BP神经网络
model.train()

# 用户输入待分类数据
print("请输入待分类数据（一行三列，以空格分隔）：")
data = input().split()
data = np.array([float(d) for d in data]).reshape(1, -1)

# 对待分类数据进行分类
prediction = model.predict(data)
print("分类结果为：", prediction[0])

在这个示例中，我们生成了100个随机的三维数据点和二元分类标签。然后，我们创建了一个具有1层5个神经元的BP神经网络，并使用train()函数进行训练。最后，我们要求用户输入一个待分类的数据点，使用predict()函数对其进行分类，并输出分类结果。