传统的机器学习方法
LogisticRegressionCV进行分类
- 显示200个待分类点
import numpy as np
import sklearn
import matplotlib
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt
print(np.__version__)
print(sklearn.__version__)
print(matplotlib.__version__)
# 手动生成一个随机的平面点分布，并画出来
np.random.seed(0)
X, y = make_moons(200, noise=0.20)
plt.scatter(X[:,0], X[:,1], s=40, c=y, cmap=plt.cm.Spectral)
plt.show()
print(X[1]) #数据
print(y[19]) #类别
- 定义一个绘制边界的函数
# 咱们先顶一个一个函数来画决策边界
def plot_decision_boundary(pred_func):
# 设定最大最小值，附加一点点边缘填充
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
h = 0.01
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
# 用预测函数预测一下
Z = pred_func(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# 然后画出图
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Spectral)
- 传统的逻辑回归分类结果
from sklearn.linear_model import LogisticRegressionCV
#咱们先来瞄一眼逻辑斯特回归对于它的分类效果
clf = LogisticRegressionCV(cv=4)
clf.fit(X, y)
# 画一下决策边界
plot_decision_boundary(lambda x: clf.predict(x)) #lambda 后的第一个参数代表传入的变量，：后代表输出的结果
plt.title("Logistic Regression")
plt.show()
搭建一个人工神经网络
- 输入变量的维度为200*2，代表200个样本，每个样本2具有维度的特征
- W1=2*3，b1=3。
- 第一个隐藏层神经元个数为3（不知道这样叫对不对，是神经元之间的权重叫做“层”还是神经元叫做“层”，这里不太确定）
- W2=3*2,b2=2
- 最后的输出结果是2003，这其中在第一层后面有一个激活函数，在第二层后面先使用softmax函数将输出值转为2002的概率矩阵，根据得到的概率矩阵使用交叉熵(损失函数)计算损失得到一个200*1的矩阵，然后将200个数加到第一行得到这一次训练的损失
- 根据得到的损失计算梯度，反向传播。不断循环这一步（前向传播计算损失->计算梯度->反向传播、更新权重）
- 最后前向传播，预测结果
网络结构图（隐含层取5个神经元的情况）
代码
num_examples = len(X) # 样本数 本例题为200
nn_input_dim = 2 # 输入的维度 本例题有两个特征向量
nn_output_dim = 2 # 输出的类别个数 分为两类
# 梯度下降参数
epsilon = 0.01 # 学习率
reg_lambda = 0.01 # 正则化参数
# 定义损失函数，计算损失(才能用梯度下降啊...)
def calculate_loss(model):
W1, b1, W2, b2 = model['W1'], model['b1'], model['W2'], model['b2']
# print("W1:{}\nb1:{}\nW2:{}\nb2:{}\n".format(W1,b1,W2,b2))
# print("X:{}\n".format(X.shape))
# 向前推进，前向运算
z1 = X.dot(W1) + b1 #200*2*2*3 =200*3, 200*3+200*3=200*3 ，z1:200*3
# print("X.dot(W1):{}".format(X.dot(W1).shape))
# print("z1:{}\n".format(z1.shape))
a1 = np.tanh(z1) #a1:200*3
# print("a1:{}".format(a1.shape))
z2 = a1.dot(W2) + b2 #200*3*3*2=200*2 , b2:1*2->200*2 , z2:200*2
# print
exp_scores = np.exp(z2) #200*2
# print("exp_scores.shape: {} ".format(exp_scores.shape))
probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) #np.sum() 将矩阵按列相加，全部加到第一列 , 200*2/200*1->200*2/200*2
# print("np.sum:{}".format(np.sum(exp_scores, axis=1, keepdims=True).shape))
# print("probs:{}".format(probs))
# 计算损失
corect_logprobs = -np.log(probs[range(num_examples), y]) #取prob这个200*2的概率矩阵的每一行，具体是第几列是靠对应的y来确定的 #200*1
# print("y:{}".format(y))
data_loss = np.sum(corect_logprobs) #200行加在一起->1*1 一个数
# print("corect_logprobs:{}".format(corect_logprobs.shape)) #200*1
# print("data_loss:{}".format(data_loss)) #200行加在一起->1*1 一个数
# 也得加一下正则化项
data_loss += reg_lambda/2 * (np.sum(np.square(W1)) + np.sum(np.square(W2))) #W1：2*3 W2:3*2 data_loss是一个数
# print("data_loss:{}".format(data_loss))
# print("1./num_examples * data_loss:{}".format(1.*data_loss/num_examples ))
return 1./num_examples * data_loss #返回一个数，作为损失值
# 完整的训练建模函数定义
def build_model(nn_hdim, num_passes=20000, print_loss=False):
'''
参数：
1) nn_hdim: 隐层节点个数
2）num_passes: 梯度下降迭代次数
3）print_loss: 设定为True的话，每1000次迭代输出一次loss的当前值
'''
# 随机初始化一下权重呗
np.random.seed(0) #seed只对第一组随机数起作用
W1 = np.random.randn(nn_input_dim, nn_hdim) / np.sqrt(nn_input_dim) # nn.sqrt打印nn_input_dim=2的开方，也就是1.414
# print("nn.sqrt:{}".format(np.sqrt(nn_input_dim)))
# print("W1:{}".format(W1))
# print(" np.random.randn(nn_input_dim, nn_hdim):{}",format( np.random.randn(nn_input_dim, nn_hdim)))
b1 = np.zeros((1, nn_hdim))
W2 = np.random.randn(nn_hdim, nn_output_dim) / np.sqrt(nn_hdim)
b2 = np.zeros((1, nn_output_dim))
# 这是咱们最后学到的模型
model = {}
# 开始梯度下降...
for i in range(0, num_passes):
# 前向运算计算loss
z1 = X.dot(W1) + b1
a1 = np.tanh(z1)
z2 = a1.dot(W2) + b2
exp_scores = np.exp(z2)
probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True)
# 反向传播
delta3 = probs
delta3[range(num_examples), y] -= 1
dW2 = (a1.T).dot(delta3)
db2 = np.sum(delta3, axis=0, keepdims=True)
delta2 = delta3.dot(W2.T) * (1 - np.power(a1, 2))
dW1 = np.dot(X.T, delta2)
db1 = np.sum(delta2, axis=0)
# 加上正则化项
dW2 += reg_lambda * W2
dW1 += reg_lambda * W1
# 梯度下降 更新参数
W1 += -epsilon * dW1
b1 += -epsilon * db1
W2 += -epsilon * dW2
b2 += -epsilon * db2
# 得到的模型实际上就是这些权重
model = { 'W1': W1, 'b1': b1, 'W2': W2, 'b2': b2}
# 如果设定print_loss了，那我们汇报一下中间状况
if print_loss and i % 1000 == 0:
# print "Loss after iteration %i: %f" %(i, calculate_loss(model))
print("Loss after iteration {}: {} ".format(i,calculate_loss(model)))
return model
# 判定结果的函数
def predict(model, x):
W1, b1, W2, b2 = model['W1'], model['b1'], model['W2'], model['b2']
# 前向运算
z1 = x.dot(W1) + b1
a1 = np.tanh(z1)
z2 = a1.dot(W2) + b2
exp_scores = np.exp(z2) #200*2
# 计算概率输出最大概率对应的类别
probs = exp_scores / np.sum(exp_scores, axis=1, keepdims=True) #200*2
# print('probs:{}'.format(probs))
return np.argmax(probs, axis=1) #返回200行中，每一行的最大的值，得到的矩阵是一个200*1的矩阵，表示200个元素对应的类别
# 建立隐层有3个节点(神经元)的神经网络
model = build_model(3, print_loss=True)
# 然后再把决策/判定边界画出来
plot_decision_boundary(lambda x: predict(model, x))
plt.title("Decision Boundary for hidden layer size 3")
plt.show()
查看不同神经元数量的分类结果
# 然后听闻你想知道不同的隐层节点个数对结果的影响？
# 那咱们来一起看看吧
plt.figure(figsize=(16, 32))
# 设定不同的隐层节点(神经元)个数
hidden_layer_dimensions = [1, 2, 3, 4, 5, 20, 50]
for i, nn_hdim in enumerate(hidden_layer_dimensions):
plt.subplot(4, 2, i+1)
plt.title('Hidden Layer size %d' % nn_hdim)
model = build_model(nn_hdim)
plot_decision_boundary(lambda x: predict(model, x))
plt.show()
参考
np.sqrt函数使用
np.argmax函数使用
np.sum函数使用
np.random.seed函数使用
python的format函数使用
扫一扫
3555
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
