#使用sklearn来产生数据并给出线性分类

from sklearn import linear_model

from sklearn import datasets

import sklearn

import numpy as np

import matplotlib.pyplot as plt

#显示医疗数据

np.random.seed(0)

#300个数据点，噪声设定0.25

X,y=datasets.make_moons(300,noise=0.25)

#显示产生的医疗数据

plt.scatter(X[:,0],X[:,1],s=50,c=y,edgecolors="Black")

plt.title('Medical data')

plt.show()

#绘制分类边界函数

def plot_boundary(pred_func,data,labels):

#pred_func为python的lambda表达式(预测函数)

#data为输入的数据

#labels为分类的结果

#设置最大值和最小值并增加0.5的边界

x_min,x_max=data[:,0].min()-0.5,data[:,0].max()+0.5

y_min,y_max=data[:,1].min()-0.5,data[:,1].max()+0.5

h=0.01 #点阵间距

#生成一个点阵网格，点阵间距为h

xx,yy=np.meshgrid(np.arange(x_min,x_max,h),np.arange(y_min,y_max,h))

#计算分类结果z

z=pred_func(np.c_[xx.ravel(),yy.ravel()])

z=z.reshape(xx.shape)

#绘制轮廓和训练样本，轮廓颜色Blues，透明度0.2

plt.contourf(xx,yy,z,cmap=
plt.cm.Blues,alpha=0.2)

plt.scatter(data[:,0],data[:,1],s=40,c=labels,edgecolors="Black")

#对球菌数据进行线性二分类

#使用scikit-learn的线性回归分类器

logistic_fun=sklearn.linear_model.LogisticRegressionCV()

clf=logistic_fun.fit(X,y)

plot_boundary(lambda x:clf.predict(x),X,y)

plt.title('Logistic Regression')

plt.show()

#建立人工神经网络模型

#定义参数

input_dim=2 #输入的维度

output_dim=2 #输出的维度，分类数

epsilon=0.01 #梯度下降算法的学习率

reg_lambda=0.01 #正则化强度

#损失函数

def calculate_loss(model,X,y):

num_examples=len(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)

probs=exp_scores/np.sum(exp_scores,axis=1,keepdims=True)

#计算损失值

correct_logprobs=-np.log(probs[range(num_examples),y])

data_loss=np.sum(correct_logprobs)

#对损失值进行归一化

data_loss+=reg_lambda/2*(np.sum(np.square(W1))+np.sum(np.square(W2)))

return 1./num_examples*data_loss

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)

probs=exp_scores/np.sum(exp_scores,axis=1,keepdims=True)

return np.argmax(probs,axis=1)

def ANN_model(X,y,nn_dim):

num_indim=len(X) #训练数据集

model={}

np.random.seed(0)

W1=np.random.randn(input_dim,nn_dim)/np.sqrt(input_dim)

b1=np.zeros((1,nn_dim))

W2=np.random.randn(nn_dim,output_dim)/np.sqrt(nn_dim)

b2=np.zeros((1,output_dim))

#批量梯度下降算法BSGD

num_passes=20000 #梯度下降迭代次数

for I in range(0,num_passes):

#向前传播

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_indim),y] -= 1

delta2=delta3.dot(W2.T)*(1-np.power(a1,2))

dW2=(a1.T).dot(delta3)

db2=np.sum(delta3,axis=0,keepdims=True)

dW1=np.dot(X.T,delta2)

db1=np.sum(delta2,axis=0)

dW1 += reg_lambda * W1

dW2 += reg_lambda * W2

#更新权重

W1 += -epsilon * dW1

b1 += -epsilon * db1

W2 += -epsilon * dW2

b2 += -epsilon * db2

model={'W1':W1,'b1':b1,'W2':W2,'b2':b2}

if I%1000==0:

print("Loss after iteration %I:%f",i,calculate_loss(model,X,y))

return model

hidden_3_model=ANN_model(X,y,3)

plot_boundary(lambda x:predict(hidden_3_model,x),X,y)

plt.title("Hidden Layer size 3")

plt.show()

#不同隐藏节点数对人工神经网络模型的影响

#定义输出图像的大小

plt.figure(figsize=(16,32))

#待输入的隐藏节点数list

hidden_layer_dimensions=[1,2,3,4,30,50,100,1000]

for I,nn_hdim in enumerate(hidden_layer_dimensions):

plt.subplot(5,2,i+1)

plt.title('Hidden Layer size %d'% nn_hdim)

model=ANN_model(X,y,nn_hdim)

plot_boundary(lambda x:predict(hidden_3_model,x),X,y)

plt.show()