def __init__(self):
'''to copy the samples and make normalization'''
Linear_Regression.__init__(self)
#to copy the samples
self.tempX = copy.copy(self.dataX)
self.tempY = copy.copy(self.dataY)
#normalization
self.tempX[1] = nm.min_max_normalization(self.tempX[1], self.xMin,
self.xMax)
self.tempY = nm.min_max_normalization(self.tempY, self.yMin, self.yMax)
def __init__(self, fileX, fileY):
"""
初始化
1_读取 training data，并处理数据。
2_初始化参数
:param trainDataFile: 训练数据文件名
:param testDataFile: 测试数据文件名
"""
# 1_读取 training data，并处理
# 1.1_读取
self.dataNum, self.dataX, dataY = self.load_dataFile(fileX, fileY)
self.inputNum = self.dataX.shape[1]
self.outputNum = int(np.max(dataY) + 1)
self.hiddenNode_num = 5
# 1.2_处理
self.xMin = self.dataX.min(axis=0)
self.xMax = self.dataX.max(axis=0)
self.dataX = nm.min_max_normalization(self.dataX, self.xMin, self.xMax)
self.dataX = self.dataX.T
self.dataY = np.zeros((self.outputNum, self.dataNum))
for i in range(dataY.size):
self.dataY[int(dataY[i]), i] = 1
# 2_初始化参数 -> 默认 hidden 层有 5 个神经元
self.w_ih = np.random.random((self.inputNum, self.hiddenNode_num))
self.b_h = np.random.random((self.hiddenNode_num, ))
self.w_ho = np.random.random((self.hiddenNode_num, self.outputNum))
self.t_o = np.random.random((self.outputNum, )) #theta_output
def gd_process_and_show(self):
#init paraments & picture
itrNum = 50 #iterator num
lr = 0.01 # lr is learning rate
#plt.ion()
plt.ioff()
lossY = []
stepX = []
#process
for i in range(itrNum):
self.thetas = self.thetas - lr * self.error_feature()
plt.cla()
#绘制 loss 图
plt.subplot(121)
stepX.append(i)
lossY.append(self.cost_function(self.tempX, self.tempY))
plt.plot(stepX, lossY)
#绘制拟合图
plt.subplot(122)
plt.xlim(self.xMin, self.xMax + 1)
plt.ylim(self.yMin, self.yMax)
plt.plot(
self.dataX[1],
nm.reverse_mm_normalization(self.tempY[:, 0], self.yMin,
self.yMax), 'ro')
plt.plot(
self.dataX[1],
nm.reverse_mm_normalization(
self.hypothesis(self.tempX.T)[:, 0], self.yMin, self.yMax))
plt.pause(0.001)
plt.ioff()
plt.show()
#get ans
print('gradient descent 的答案为：')
print('最后得到的参数为：', self.thetas[:, 0])
tempX = 14 / 13
ans = self.hypothesis(np.array([1, tempX]))[0]
ans = nm.reverse_mm_normalization(ans, self.yMin, self.yMax)
print('2014年的预测结果为：', ans)
def plot_testResult(self, testXFile, testYFile=''):
"""绘制分类图，由数据点和分类线构成。
注意:
1_在画图之前先对数据预处理
2_数据点用红蓝两色来区分不同的分类
:param testXFile: 测试数据 input 的文件名
:param testYFile: 测试数据 output 的文件名
:return: 无
"""
if testYFile != '':
# 预处理
dataNum, dataX, tempDataY = self.load_dataFile(
testXFile, testYFile)
dataX = nm.min_max_normalization(dataX, self.xMin, self.xMax)
dataX = dataX.T
dataY = np.zeros((self.outputNum, dataNum))
for i in range(tempDataY.size):
dataY[int(tempDataY[i]), i] = 1
xL = 0
xR = 1 # 分别代表散点图 x 轴的左右范围
yL = 0
yH = 1 # 分别代表散点图 y 轴的下上范围
mk = ['+', '^', 'o']
cs = ['b', 'r', 'k'] # 分别代表散点标记、散点颜色的取值可能
plt.title('ann test')
plt.xlabel("x1")
plt.ylabel("x2")
# 1_绘图
# 1.1_绘制背景
tempRange = 100 # 代表要将 x、y 轴分为多少段
meshX, meshY = np.meshgrid(np.linspace(xL, xR, tempRange),
np.linspace(yL, yH, tempRange))
# 注意 meshX、meshY 都是二维的
meshData = np.vstack((meshX.flatten(), meshY.flatten()))
meshPredic = self.calculateY(meshData)[1]
meshClass = self.get_preClass(meshPredic)[0]
plt.contourf(meshX, meshY, meshClass.reshape(meshX.shape))
# 1.2_绘制散点
pltTool = np.argmax(dataY, axis=0)
for j in range(dataNum):
plt.scatter(dataX[0, j],
dataX[1, j],
marker=mk[pltTool[j]],
c=cs[pltTool[j]])
plt.show()
# 2_计算准确率
yPre = self.calculateY(dataX)[1]
accuracy = self.get_accuracy(yPre, dataY)
return accuracy
def plot_testResult(self, testXFile, testYFile=''):
"""绘制分类图，由数据点和分类线构成。
注意:
1_在画图之前先对数据预处理
2_数据点用红蓝两色来区分不同的分类
:param testXFile: 测试数据 input 的文件名
:param testYFile: 测试数据 output 的文件名
:return: 无
"""
# 初始化画图所用参数
mk = ['+', '^', 'o']
cs = ['k', 'r', 'b'] # 分别代表背景颜色、散点标记、散点颜色的取值可能
xL = 0
xR = 1 # 分类图 x 轴的左右边界
yL = 0
yH = 1 # 分类图 y 轴的下上边界
partNum = 100 # 将分类图的每个轴分多少部分
if testYFile != '':
dataNum, dataX, dataY = self.load_dataFile(testXFile, testYFile)
dataX = nm.min_max_normalization(dataX, self.xMin, self.xMax)
add = np.ones((dataNum, 1))
dataX = np.hstack([add, dataX]).T
# 绘制分类图
plt.title('muti-perceptron test')
plt.xlabel('x1')
plt.ylabel('x2')
# 1_绘制背景
meshX, meshY = np.meshgrid(np.linspace(xL, xR, partNum),
np.linspace(yL, yH, partNum))
add = np.ones((meshX.size, ))
meshData = np.vstack((add, meshX.flatten()))
meshData = np.vstack((meshData, meshY.flatten()))
meshPrdic = self.hypothesis(meshData)[1]
plt.contourf(meshX, meshY, meshPrdic.reshape(meshX.shape))
# 2_绘制散点 & 打印准确率
for i in range(dataNum):
tempC = int(dataY[i])
plt.scatter(dataX[1, i],
dataX[2, i],
marker=mk[tempC],
c=cs[tempC])
plt.show()
# 3_计算准确率
classAns = self.hypothesis(dataX)[1]
return self.get_accuracy(classAns, dataY)
def __init__(self, fileX, fileY):
"""初始化
1_读取 training data，并处理数据。
2_初始化参数
:param trainDataFile: 训练数据文件名
:param testDataFile: 测试数据文件名
:param clfNum: classfication num
"""
# 1_读取 training data，并处理
# 1.1_读取
self.dataNum, self.dataX, self.dataY = self.load_dataFile(fileX, fileY)
# 1.2_处理
self.xMin = self.dataX.min(axis=0)
self.xMax = self.dataX.max(axis=0)
self.dataX = nm.min_max_normalization(self.dataX, self.xMin, self.xMax)
addDataX = np.ones((self.dataNum, 1))
self.dataX = np.hstack((addDataX, self.dataX)).T
# 2_初始化参数
self.thetas = np.zeros((self.dataX.shape[0], ))
def __init__(self, fileX, fileY):
"""导入数据并做处理；创建参数向量并设初值；创建相关参数
:param fileName: traning data 所在目录(不包含文件名)
"""
#导入数据并做处理
#导入数据: 样本个数，input 数据,label 数据
self.dataNum, self.dataX, self.dataY = self.load_data(fileX, fileY)
self.xMin = self.dataX.min(axis=0)
self.xMax = self.dataX.max(axis=0)
#处理
#1.1_归一化
self.dataX = nm.min_max_normalization(self.dataX, self.xMin, self.xMax)
#1.2_为每个 input 增加一个值为 1 的元素，方便之后与 参数做内积。并得到参数维度
self.dataX = commonTools.join_biasTerm(self.dataNum, self.dataX)
#1.3_转换 xData，使其中的每个 input 向量均为列向量
self.dataX = self.dataX.T
#2.3_转换 yData，使其变成列向量。
#因为 yData 是一维的，无法转置，所以先要更改其维度再进行转置操作。
self.dataY = np.atleast_2d(self.dataY).T
#初始化参数
self.thetas = np.zeros((self.dataX.shape[0], 1))
def plot_testResult(self,testFileX,testFileY = ''):
"""绘制与打印预测结果（包括一个分类图和一个准确率）
注意:
分情况讨论是否给出 testY 的两种情况。
:param testX: 预测数据 input 的文件名
:param testY: 预测数据 output 的文件名
:return: 无
"""
#初始化画图所用参数
mk = ['+', '^', 'o']; cs = ['k', 'r', 'b']
# 分别代表背景颜色、散点标记、散点颜色的取值可能
xL = 0; xR = 1 #分类图 x 轴的左右边界
yL = 0; yH = 1 #分类图 y 轴的下上边界
partNum = 100 #将分类图的每个轴分多少部分
if testFileY != '':
dataNum,dataX,dataY = self.load_dataFile(testFileX,testFileY)
dataX = nm.min_max_normalization(dataX,self.xMin,self.xMax)
add = np.ones((dataNum,1))
dataX = np.hstack([add,dataX]).T
dataY = np.atleast_2d(dataY).T
#绘制分类图
plt.title('softmax test')
plt.xlabel('x1'); plt.ylabel('x2')
#1_绘制背景
meshX,meshY = np.meshgrid(np.linspace(xL,xR,partNum),
np.linspace(yL,yH,partNum))
add = np.ones((meshX.size,))
meshData = np.vstack((add,meshX.flatten()))
meshData = np.vstack((meshData,meshY.flatten()))
meshPrdic = self.get_classResult(meshData)
plt.contourf(meshX,meshY,meshPrdic.reshape(meshX.shape))
#2_绘制散点 & 打印准确率
for i in range(dataNum):
tempC = int(dataY[i,0])
plt.scatter(dataX[1,i],dataX[2,i],
marker = mk[tempC],c = cs[tempC])
hAns = self.get_classResult(dataX)
plt.show()
return self.get_accuracy(hAns,dataY)
def plot_testResult(self, testXFile, testYFile=''):
"""绘制分类图，由数据点和分类线构成。
注意:
1_在画图之前先对数据预处理
2_数据点用红蓝两色来区分不同的分类
:param testXFile: 测试数据 input 的文件名
:param testYFile: 测试数据 output 的文件名
:return: 无
"""
if testYFile != '':
#预处理
dataNum, dataX, dataY = self.load_data(testXFile, testYFile)
dataX = nm.min_max_normalization(dataX, self.xMin, self.xMax)
add = np.ones((dataX.shape[0], 1))
dataX = np.hstack((add, dataX)).T
dataY = np.atleast_2d(dataY).T
# 1_绘制数据点
plt.title('logistic test')
plt.xlabel("x1")
plt.ylabel("x2")
for j in range(dataX.shape[1]):
if dataY[j, 0] == 1:
plt.plot(dataX[1, j], dataX[2, j], 'ro')
else:
plt.plot(dataX[1, j], dataX[2, j], 'bo')
# 2_绘制分类线
# 思路：
# 因为模型的预测结果是通过比较sigmoid函数的输出与0.5得到的。
# 而当sigmoid函数output为0.5时，w0 + w1*x1 + w2*x2 = 0。
# 又因为图像的x、y轴分别为参数 x1、x2。
# 所以，分类线可以表示成 x2 = -(w0 + w1*x1)/w2
x = np.linspace(-0.5, 1.2, 50)
y = -(self.thetas[0][0] +
self.thetas[1][0] * x) / self.thetas[2][0]
plt.plot(x, y, 'k')
# 3_计算准确率
hAns = self.hypothesis(dataX)
plt.show()
return self.get_accuracy(hAns, dataY)
def plot_testResult(self, testXFile, testYFile=''):
"""绘制分类图，由数据点和分类线构成。
注意:
1_在画图之前先对数据预处理
2_数据点用红蓝两色来区分不同的分类
:param testXFile: 测试数据 input 的文件名
:param testYFile: 测试数据 output 的文件名
:return: 无
"""
if testYFile != '':
# 预处理
dataNum, dataX, dataY = self.load_dataFile(testXFile, testYFile)
dataX = nm.min_max_normalization(dataX, self.xMin, self.xMax)
add = np.ones((dataX.shape[0], 1))
dataX = np.hstack((add, dataX)).T
# 1_绘制数据点
plt.title('perceptron test')
plt.xlabel("x1")
plt.ylabel("x2")
for j in range(dataX.shape[1]):
if dataY[j] == 1:
plt.plot(dataX[1, j], dataX[2, j], 'ro')
else:
plt.plot(dataX[1, j], dataX[2, j], 'bo')
# 2_绘制分类线
# 思路：
# 超平面函数，w0 + w1*x1 + w2*x2 = 0。
# 又因为图像的x、y轴分别为参数 x1、x2。
# 所以，分类线可以表示成 x2 = -(w0 + w1*x1)/w2
x = np.linspace(0, 1, 50)
y = -(self.thetas[0] + self.thetas[1] * x) / self.thetas[2]
plt.plot(x, y, 'k')
# 3_计算准确率
classAns = self.hypothesis(dataX)
plt.show()
return self.get_accuracy(classAns, dataY)