逻辑回归的数学推导与代码实现

数学推导

sigmoid函数推导

极大似然估计构造损失函数

多分类逻辑回归（softmax回归）

代码实现

逻辑回归

class LogisticRegressionClassifier:
    def __init__(self, eta=0.01, n_iters=1e4, epslion=1e-7):
        self._theta = None
        self.m = None
        self.n = None
        self.eta = eta
        self.n_iters = n_iters
        self.epslion = epslion

    def fit(self,X_train, y_train):
        """
        :param X_train: 训练特征集
        :param y_train: 训练结果集
        :param eta: 学习率
        :param n_iters: 最大循环次数
        :param epslion: 误差
        :return:
        """
        assert X_train.shape[0] == y_train.shape[0]
        self.m=X_train.shape[0]
        self.n=X_train.shape[1]
        theta = np.zeros(X_train.shape[1]).reshape(-1, 1)
        y_train=y_train.reshape(-1,1)

        def h(X,theta):
            res=X.dot(theta)
            return 1 / (1+np.exp(-res))

        def J(X,y,theta):
            res=y*np.log10(h(X,theta))+(1-y)*np.log10(1-h(X,theta))
            return -(np.sum(res) / self.m)

        def dJ(X,theta):
            beta=h(X,theta)-(y_train)
            res=(X.T).dot(beta)
            return res / self.m

        for _ in range(int(self.n_iters)):
            gredient=dJ(X_train,theta)
            last_theta=theta
            theta=theta-self.eta*gredient
            if (abs(J(X_train,y_train,theta)-J(X_train,y_train,last_theta))<self.epslion):
                break

        self._theta=theta
        return self

    def predict(self,X_test):
        assert self._theta is not None
        res=X_test.dot(self._theta)
        res=1 / (1+np.exp(-res))
        for i in range(len(X_test)):
            if res[i]>0.5: res[i]=1
            else: res[i]=0
        return res

    def accuracy(self,y_predict,y_test):
        return np.sum(y_predict==y_test) / len(y_test)

softmax回归

class SoftmaxRegressionClassifier:
    def __init__(self, n_iters=100, alpha=0.1):
        self.weight = None
        self.n_iters = n_iters
        self.alpha = alpha


    def fit(self, X_train, y_train):
        def softmax(X):
            return np.exp(X) / np.sum(np.exp(X))

        target_nums = len(set(y_train))
        self.weight = np.random.random((target_nums, X_train.shape[1]))
        for _ in range(self.n_iters):
            for i in range(len(X_train)):
                x = X_train[i].reshape(-1, 1)
                y = np.zeros((target_nums, 1))
                y[y_train[i]] = 1
                _y = softmax(np.dot(self.weight, x))
                a = (np.dot((_y - y), x.T))
                self.weight -= self.alpha * a

    def predict(self, X_test):
        return np.argmax(self.weight.dot(X_test.T), axis=0)