详细代码参考github

多类分类 Multi-class Classificaition

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

1.可视化数据

识别的手写数字图片为20*20像素，每个像素值表示了该位置的灰度值。训练集中共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开始的。

3.梯度函数

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

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%