第七章 多层神经网络—解决非线性问题（深度学习之TensorFlow入门、原理与进阶实战）

实例28：用线性单分逻辑回归分析肿瘤是良性还是恶性的：

from sklearn.utils import shuffle###
def generate(sample_size, mean, cov, diff, regression):
    num_classes = 2 
    samples_per_class = int(sample_size/2)
    
    X0 = np.random.multivariate_normal(mean, cov, samples_per_class)#方法用于根据实际情况生成一个多元正态分布矩阵,mean = 1
    Y0 = np.zeros(samples_per_class)
    
    for ci, d in enumerate(diff):
        X1 = np.random.multivariate_normal(mean+d, cov, samples_per_class)
        Y1 = (ci+1)*np.ones(samples_per_class)
        
        X0 = np.concatenate((X0,X1))#numpy提供了numpy.concatenate((a1,a2,...), axis=0)函数。能够一次完成多个数组的拼接。其中a1,a2,...是数组类型的参数
        Y0 = np.concatenate((Y0,Y1))#适合大量数据
          
    if regression == False:
        class_ind = [Y == class_number for class_number in range(num_classes)]
        Y = np.asarry(np.hstack(class_ind), dtype=np.float32)
        #array和asarray都可将结构数据转换为ndarray类型。但是主要区别就是当数据源是ndarray时，array仍会copy出一个副本，占用新的内存，但asarray不会。
    

    #X=random.shuffle(X0)
    #Y=random.shuffle(Y0)#shuffle() 方法将序列的所有元素随机排序   import random  random.shuffle (lst )
    X, Y = shuffle(X0, Y0)

    return X,Y
        
    
    
import numpy as np
import matplotlib.pyplot as plt
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
np.random.seed(10)
num_classes = 2
mean = np.random.randn(num_classes)
cov = np.eye(num_classes)
X, Y = generate(1000, mean, cov, [3.0], True)
colors = ['r' if l == 0 else 'b' for l in Y[:]]
plt.scatter(X[:,0], X[:,1], c=colors)
plt.xlabel("Scaled age (in yrs)")
plt.ylabel("Tumor size (in cm)")
plt.show()
lab_dim = 1
#构建网络结构
input_dim = 2
input_features = tf.placeholder(tf.float32, [None, input_dim])
input_lables = tf.placeholder(tf.float32, [None, lab_dim])
#定义学习参数
W = tf.Variable(tf.random_normal([input_dim,lab_dim]), name = 'weight')
b = tf.Variable(tf.zeros([lab_dim]), name = 'bias')

output = tf.nn.sigmoid(tf.matmul(input_features, W) + b)
cross_entropy = -(input_lables * tf.log(output) + (1- input_lables) * tf.log(1 - output))
ser = tf.square(input_lables - output)
loss = tf.reduce_mean(cross_entropy)
err = tf.reduce_mean(ser)
optimizer = tf.train.AdamOptimizer(0.04)
train = optimizer.minimize(loss)
#训练
maxEpochs = 50
minibatchsize = 25
#启动session
with tf.Session() as sess:
    tf.global_variables_initializer().run()
    #向模型输入数据
    for epoch in range(maxEpochs):
        sumerr = 0
        for i in range(np.int32(len(Y)/minibatchsize)):
            x1 = X[i * minibatchsize: (i+1)*minibatchsize,:]
            y1 = np.reshape(Y[i * minibatchsize:(i+1)*minibatchsize], [-1,1])
            tf.reshape(y1,[-1,1])
            _,lossval,outputval,errval = sess.run([train, loss, output,err], feed_dict = {input_features: x1, input_lables: y1})
            sumerr = sumerr + errval
            
        print("Epoch:",'%04d'%(epoch+1), "cost =","{:.9f}".format(lossval),"err =",sumerr/minibatchsize)
        
        
    #数据可视化
    train_X, train_Y = generate(100, mean, cov, [3.0], True)
    colors = ['r'if l == 0 else 'b' for l in train_Y[:]]
    plt.scatter(train_X[:,0], train_X[:,1], c = colors)
    x = np.linspace(-1,8,200)
    y = -x*(sess.run(W)[0]/sess.run(W)[1])-sess.run(b)/sess.run(W)[1]
    plt.plot(x,y, label = 'Fitted line')
    plt.legend()
    plt.show()

运行结果：

实例29：用线性逻辑回归处理多线性分类问题

# -*- coding: utf-8 -*-

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

import numpy as np

import matplotlib.pyplot as plt

 

from sklearn.utils import shuffle

from matplotlib.colors import colorConverter, ListedColormap 

    

# 对于上面的fit可以这么扩展变成动态的

from sklearn.preprocessing import OneHotEncoder

def onehot(y,start,end):

    ohe = OneHotEncoder()

    a = np.linspace(start,end-1,end-start)

    b =np.reshape(a,[-1,1]).astype(np.int32)

    ohe.fit(b)

    c=ohe.transform(y).toarray()  

    return c     

#

    

def generate(sample_size, num_classes, diff,regression=False):

    np.random.seed(10)

    mean = np.random.randn(2)

    cov = np.eye(2)  

    

    #len(diff)

    samples_per_class = int(sample_size/num_classes)

 

    X0 = np.random.multivariate_normal(mean, cov, samples_per_class)

    Y0 = np.zeros(samples_per_class)

    

    for ci, d in enumerate(diff):

        X1 = np.random.multivariate_normal(mean+d, cov, samples_per_class)

        Y1 = (ci+1)*np.ones(samples_per_class)

    

        X0 = np.concatenate((X0,X1))

        Y0 = np.concatenate((Y0,Y1))

        #print(X0, Y0)

    

  

    if regression==False: #one-hot  0 into the vector "1 0

        Y0 = np.reshape(Y0,[-1,1])        

        #print(Y0.astype(np.int32))

        Y0 = onehot(Y0.astype(np.int32),0,num_classes)

        #print(Y0)

    X, Y = shuffle(X0, Y0)

    #print(X, Y)

    return X,Y    

 

 

# Ensure we always get the same amount of randomness

np.random.seed(10)

 

input_dim = 2

num_classes =3 

X, Y = generate(2000,num_classes,  [[3.0],[3.0,0]],False)

aa = [np.argmax(l) for l in Y]

colors =['r' if l == 0 else 'b' if l==1 else 'y' for l in aa[:]]

 

plt.scatter(X[:,0], X[:,1], c=colors)

plt.xlabel("Scaled age (in yrs)")

plt.ylabel("Tumor size (in cm)")

plt.show()

 

#参考了https://blog.****.net/weixin_37993251/article/details/89601178该文

运行截图：

#构建网络结构
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
lab_dim = num_classes
#定义占位符
input_features = tf.placeholder(tf.float32, [None, input_dim])
input_labels = tf.placeholder(tf.float32, [None, lab_dim])
#定义学习参数
W = tf.Variable(tf.random_normal([input_dim, lab_dim]),name = 'weight')
b = tf.Variable(tf.zeros([lab_dim]),name = 'bias')
output = tf.matmul(input_features, W)+ b
z = tf.nn.softmax(output)

a1 = tf.argmax(tf.nn.softmax(output), axis = 1)#按行找出索引值，生成数组
b1 = tf.argmax(input_labels, axis = 1)
err = tf.count_nonzero(a1-b1)#两个数组相减，不为0就是错误个数
cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels= input_labels,logits=output)
loss = tf.reduce_mean(cross_entropy)
optimizer = tf.train.AdamOptimizer(0.04)
train = optimizer.minimize(loss)

 

#训练
maxEpochs = 50
minibatchsize = 25
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    
    for epoch in range(maxEpochs):
        sumerr = 0
        for i in range(np.int32(len(Y)/minibatchsize)):
            x1 = X[i * minibatchsize:(i+1)*minibatchsize,:]
            y1 = Y[i * minibatchsize:(i+1)*minibatchsize,:]
            
            _,lossval, outputval,errval = sess.run([train,loss,output,err], feed_dict = {input_features: x1, input_labels:y1})
            sumerr= sumerr + (errval/minibatchsize)
        print("Epochs:", '%04d'%(epoch+1),"cost=","{:.9f}".format(lossval),"err=",sumerr/minibatchsize)
    
#数据可视化
    train_X,train_Y = generate(200,num_classes, [[3.0],[3.0,0]],False)
    aa = [np.argmax(1) for l in train_Y]
    colors = ['r'if l ==0 else 'b' if l==1 else 'y' for l in aa[:1]]
    plt.scatter(train_X[:,0], train_X[:,1], c=colors)

    x=np.linspace(-1,8,200)
    y=-x*(sess.run(W)[0][0]/sess.run(W)[1][0])-sess.run(b)[0]/sess.run(W)[1][0]
    plt.plot(x,y, label='first line', lw=3)
    
    y=-x*(sess.run(W)[0][1]/sess.run(W)[1][1])-sess.run(b)[1]/sess.run(W)[1][1]
    plt.plot(x,y, label='second line',lw=2)
    
    y=-x*(sess.run(W)[0][2]/sess.run(W)[1][2])-sess.run(b)[2]/sess.run(W)[1][2]
    plt.plot(x,y, label='third line', lw=1)

    plt.legend()
    plt.show()
    print(sess.run(W), sess.run(b))
    
    
    #模型可视化
    train_X,train_Y = generate(200, num_classes, [[3.0], [3.0, 0]], False)
    aa = [np.argmax(1) for l in train_Y]
    colors = ['r' if l==0 else 'b' if l==1 else 'y' for l in aa[:]]
    plt.scatter(train_X[:,0], train_X[:,1], c=colors)
    
    nb_of_xs = 200
    xs1 = np.linspace(-1, 8, num=nb_of_xs)
    xs2 = np.linspace(-1, 8, num=nb_of_xs)
    xx,yy = np.meshgrid(xs1, xs2)
    #初始化和填充classification plane
    classification_plane = np.zeros((nb_of_xs, nb_of_xs))
    for i in range(nb_of_xs):
        for j in range(nb_of_xs):
            classification_plane[i, j] = sess.run(a1, feed_dict= {input_features: [[xx[i,j], yy[i,j] ]]})
     #创建color map显示
    cmap = ListedColormap([
        colorConverter.to_rgba('r', alpha=0.30),
        colorConverter.to_rgba('b', alpha=0.30),
        colorConverter.to_rgba('y', alpha=0.30)])
    #图示各个样本边界
    plt.contourf(xx,yy,classification_plane, cmap=cmap)
    plt.show()

 

运行截图：