多类分类OneVsAll（吴恩达课程Octave代码用pytho

详细代码参考github

多类分类 Multi-class Classificaition

实例：建立逻辑回归模型识别手写数字（0-9）。

1.可视化数据

识别的手写数字图片为2020*像素，每个像素值表示了该位置的灰度值。训练集中共5000个手写字，将每个手写字“拉直”，数据维度（5000，400），分类结果维度（5000, 1）。

注意： Ocatave中的reshape和numpy中的reshape有点区别，它们刚好是一个转置的区别。另外数据集每行表示一个手写字，需要把长度200的向量压缩回20*20的图像，才能显示。

5000张图片中，随机选取100张进行绘制，每张中间设置一条1像素的白色边界，横向10张，纵向10张，如下图所示。由于每次都是随机，显示结果可能不一致。

数据可视化
参考代码：

def displayData(self):
    example_width = int(np.sqrt(self.pics.shape[1]))  # 每张图片的宽
    example_hight = self.pics.shape[1] // example_width

    display_rows = int(np.sqrt(self.pics.shape[0]))  # 每行显示几张图片
    display_cols = self.pics.shape[0] // display_rows
    # print(self.pics[45, :])
    display_array = np.ones((1+display_rows*(example_hight+1), 1+display_cols*(example_width+1)))*200
    curr_ex = 0  # 当前每行张数
    for i in range(display_rows):
        for j in range(display_cols):
            if curr_ex >= self.pics.shape[0]:
                break
            max_val = np.max(np.abs(self.pics[curr_ex, :]))
            display_array[1+j*(example_hight+1):(j+1)*(example_hight+1), 1+i*(example_width+1):(i+1)*(example_width+1)] = \
                self.pics[curr_ex, :].reshape((20, 20)).transpose()/max_val*255
            curr_ex += 1

        if curr_ex >= self.pics.shape[0]:
            break
    plt.xticks([])
    plt.yticks([])
    plt.imshow(display_array, cmap='gray')
    plt.show()

2.损失函数

同上节博客中损失函数没有任何区别，直接粘贴公式，注意正则化项 j是从1开始的。

costJ

3.梯度函数

同样没有区别，直接写出，注意正则化项 j是从1开始的。

Gradient

4.计算最优theta

使用scipy.optimize中的minimize函数，注意参数的数量，在梯度和损失函数定义的两个函数中，传入参数为4个，故minimize函数使用args=()参数，参数按照梯度和损失函数输入参数的顺序。
参考代码：

def lrCostFunction(self, theta, x, y, lamda):
    m = y.shape[0]
    J = (-np.dot(y.T, np.log(self.sigmoid(x.dot(theta))))-np.dot((1-y).T, np.log(1-self.sigmoid(x.dot(theta))))) / m+ (lamda*np.sum(theta[1::]**2, axis=0))/(2*m)  # 正则化是从j = 1开始的
    return J

def lrGradient(self, theta, x, y, lamda):
    m = y.shape[0]
    theta = theta.reshape((x.shape[1], 1))
    grad = np.zeros((x.shape[1], 1))
    grad[0] = np.dot(x[:, 0:1].T, (self.sigmoid(x.dot(theta))-y)) / m
    grad[1::] = np.dot(x[:, 1::].T, (self.sigmoid(x.dot(theta))-y)) / m + lamda*theta[1::] / m
    return grad

def fmini(self):
    x = np.hstack([np.ones((self.train_x.shape[0], 1)), self.train_x])  # (5000, 401)
    y = self.train_y
    # fmincg = op.fmin_cg(f=self.lrCostFunction, x0=self.init_theta, fprime=self.lrGradient, args=(x, np.array(y==(1+1), np.int), 0.1)) #报错
    self.optiTheta = np.zeros((10, 401))
    for i in range(10):
        fmini = op.minimize(fun=self.lrCostFunction, x0=self.init_theta, args=(x, np.array(y==(i+1), np.int), 0.1), method='TNC', jac=self.lrGradient)
        print("训练第%d部分"%(i+1))
        self.optiTheta[i, :] = fmini['x']
    return self.optiTheta

5.计算准确率

这里使用了两种方式：

1. 数据集全部用来训练，然后利用求得的theta返回去计算准确率，这种情况下准确率高达96.4%；
2. 将数据集分为training set和testing set，80%训练集，20%测试集，这种情况下准确率达到89.1%。

参考代码：

def predictOneVsAll(self):
    x = np.hstack([np.ones((self.test_x.shape[0], 1)), self.test_x])  # (1000, 401)
    position = np.argmax(self.sigmoid(x.dot(self.optiTheta.T)), axis=1) + 1
    accuracy = np.mean(position.reshape(1000, 1) == self.test_y)*100
    # print(position[:50])
    # print("100%traingset accuracy:{}".format(accuracy))  # 96.46%
    print("In 80%traing set, 20%testing set condition, accuracy is  {}".format(accuracy))  # 89.1%