多层BP神经网络参数高自由度Python

这是用python实现的多层BP神经网络，详细简介：
1）层数、输入神经元个数、隐藏层神经元个数、输出神经元个数可定制；
2）隐藏层激励函数可选：tanh、logistic，可自行拓展到字典中；
3）内含多分类编码器，多分类数据集类标无需编码可直接输入输出；
4）输出层激励函数固定为sigmoid，在predict方法可以设置是否返回概率值。
初学机器学习，如编写有问题请不吝赐教，如果有疑问也欢迎讨论，QQ：1642990705

import numpy as np

class BPNNClassifier:
    def __init__（self feature_n hidden_n=10 deep=2 label_n=2 eta=0.1 max_iter=200 activate_func=“tanh“）:
        self.feature_n = feature_n
        self.hidden_n = hidden_n
        self.deep = deep
        self.label_n = label_n
        self.eta = eta
        self.max_iter = max_iter
        self.weights = []
        self.gradients = list（range（deep）） # save the gradient of every neuron
        self.values = [] # save the activated value of every neuron
        activate_funcs = \
            {“tanh“:（self.tanh self.dtanh） “sigmoid“:（self.sigmoid self.dsigmoid）}
        self.activate_func self.dactivate_func = activate_funcs[activate_func]
        for d in range（deep）:
            if d == 0: # input layer to hidden layer
                weight = np.random.randn（hidden_n feature_n + 1）
            elif d == self.deep - 1: # hidden layer to output layer
                label_n = 1 if label_n == 2 else label_n
                weight = np.random.randn（label_n hidden_n）
            else: # the others
                label_n = 1 if label_n == 2 else label_n
                weight = np.random.randn（hidden_n hidden_n）
            self.weights.append（weight）

    def linear_input（self deep X）:
        weight = self.weights[deep]
        return X @ weight.T

    def activation（self z func）:
        return func（z）

    def sigmoid（self z）:
        return 1 / （1 + np.exp（-z））

    def dsigmoid（self h）:
        return h * （1 - h）

    def tanh（self z）:
        return （np.exp（z） - np.exp（-z）） / （np.exp（z） + np.exp（-z））

    def dtanh（self h）:
        return 1 - h ** 2

    def preproccessing（self X=None y=None）:
        X_y = []
        if isinstance（X np.ndarray）:
            X0 = np.array（[[1] for i in range（X.shape[0]）]）
            X = np.hstack（[X0 X]）
            X_y.append（X）
        if isinstance（y np.ndarray）:
            y = self.encoder（y）
            X_y.append（y）
        return tuple（X_y）

    def encoder（self y）:
        y_new = []
        if y.ndim == 1: # encode y to one hot code
            if self.label_n > 2:
                for yi in y:
                    yi_new = np.zeros（self.label_n）
                    yi_new[yi] = 1
                    y_new.append（yi_new）
                y_new = np.array（y_new）
            else:
                y_new = y
        elif y.ndim == 2: # encode y to 1D array
            if self.label_n > 2:
                for yi in y:
                    for j in range（len（yi））:
                        if yi[j] == 1:
                            y_new.append（j）
                            break
                y_new = np.array（y_new）
            else:
                y_new = y.ravel（）
        else:
            raise Exception（“argument value error: ndarray ndim should be 1 or 2“）
        return y_new

    def forward_propagation（self X）:
        self.values.clear（）
        value = None
        for d in range（self.deep）:
            if d == 0: # input lay