2018年9月13日笔记
0.检测tensorflow环境
安装tensorflow命令：pip install tensorflow

下面一段代码能够成功运行，则说明安装tensorflow环境成功。
import tensorflow as tf
hello = tf.constant('hello world')
session = tf.Session()
session.run(hello)

上面一段代码成功运行的结果如下图所示：






image.png

1.数据准备
从下图可以看出，变量a为1维的ndarray对象时，a[:, np.newaxis]与a.reshape(-1, 1)相同。





image.png

import numpy as np

X = np.linspace(-1, 1, 300)[:, np.newaxis].astype('float32')
noise = np.random.normal(0, 0.05, X.shape).astype('float32')
y = np.square(X) - 0.5 + noise

第1行代码导入numpy库，起别名np；

第3行代码调用np.linspace方法获得一个区间内的等间距点，例如np.linspace(0, 1, 11)是获取[0, 1]区间的11个等间距点。如下图所示：





image.png


第4行代码调用np.random.normal方法初始化符合正态分布的点，第1个参数是正态分布的均值，第2个参数是正态分布的方差，第3个参数是返回值的shape，返回值的数据类型为ndarray对象。

第5行代码调用np.square方法对X中的每一个值求平方，- 0.5使用了ndarray对象的广播特性，最后加上噪声noise，将计算结果赋值给变量y。

2.搭建神经网络
import tensorflow as tf 

Weights_1 = tf.Variable(tf.random_normal([1, 10]))
biases_1 = tf.Variable(tf.zeros([1, 10]) + 0.1)
Wx_plus_b_1 = tf.matmul(X, Weights_1) + biases_1
outputs_1 = tf.nn.relu(Wx_plus_b_1)
Weights_2 = tf.Variable(tf.random_normal([10, 1]))
biases_2 = tf.Variable(tf.zeros([1, 1]) + 0.1)
Wx_plus_b_2 = tf.matmul(outputs_1, Weights_2) + biases_2
outputs_2 = Wx_plus_b_2
loss = tf.reduce_mean(tf.square(y - outputs_2))
optimizer = tf.train.AdamOptimizer(0.1)
train = optimizer.minimize(loss)

第1行代码导入tensorflow库，起别名tf；

第3-6这4行代码定义神经网络中的输入层到第1隐层的连接；

第7-10这4行代码定义神经网络中的第1隐层到输出层的连接；

第3、7行代码定义Weights，它的形状是连接上一层神经元的个数*连接下一层神经元的个数；

第4、8行代码定义biases，它是二维矩阵，行数一直为1，列数为连接下一层神经元的个数，即它的形状为1*连接下一层神经元的个数；

第5、9行代码表示wx+b的计算结果;

第6行代码表示在第1个连接的输出结果，经过激活函数relu得出；

第10行代码表示在第2个连接的输出结果，因为此连接的下一层是输出层，所以不需要激活函数。

第11行代码定义损失函数，等同于回归预测中的MSE，中文叫做均方误差，数据类型如下图所示：





image.png


第12行代码调用tf.train库中的AdamOptimizer方法实例化优化器对象，数据类型如下图所示：





image.png


第13行代码调用优化器的minimize方法定义训练方式，参数为损失函数。方法的返回结果赋值给变量train，数据类型如下图所示：





image.png

3.变量初始化
init = tf.global_variables_initializer()
session = tf.Session()
session.run(init)

对于神经网络模型，重要是其中的W、b这两个参数。

开始神经网络模型训练之前，这两个变量需要初始化。

第1行代码调用tf.global_variables_initializer实例化tensorflow中的Operation对象。






image.png

第2行代码调用tf.Session方法实例化会话对象；

第3行代码调用tf.Session对象的run方法做变量初始化。

4.模型训练
模型训练200次，每运行1次代码session.run(train)则模型训练1次。

在训练次数为20的整数倍时，打印训练步数、loss值。
for step in range(201):
    session.run(train)
    if step % 20 == 0:
        print(step, 'loss:', session.run(loss))

上面一段代码的运行结果如下：

0 loss: 0.23739298

20 loss: 0.0074774586

40 loss: 0.0032493745

60 loss: 0.0026177235

80 loss: 0.0025075015

100 loss: 0.002472407

120 loss: 0.0024537172

140 loss: 0.002427246

160 loss: 0.002398049

180 loss: 0.002373801

200 loss: 0.002357695

5.完整代码
下面代码与前文相比，将搭建神经网络时重复定义Weights、biases的步骤封装成了函数。
import numpy as np
import tensorflow as tf 

X = np.linspace(-1, 1, 300)[:, np.newaxis].astype('float32')
noise = np.random.normal(0, 0.05, X.shape).astype('float32')
y = np.square(X) - 0.5 + noise

def addConnect(inputs, in_size, out_size, activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if not activation_function:
        return Wx_plus_b
    else:
        return activation_function(Wx_plus_b)

connect_1 = addConnect(X, 1, 10, tf.nn.relu)
predict_y = addConnect(connect_1, 10, 1)
loss = tf.reduce_mean(tf.square(y - predict_y))
optimizer = tf.train.AdamOptimizer(0.1)
train = optimizer.minimize(loss)

init = tf.global_variables_initializer()
session = tf.Session()
session.run(init)

for step in range(201):
    session.run(train)
    if step % 20 == 0:
        print(step, 'loss:', session.run(loss))

上面一段代码的运行结果如下：

0 loss: 0.28191957

20 loss: 0.011470509

40 loss: 0.0044303066

60 loss: 0.003392854

80 loss: 0.0031887146

100 loss: 0.0030761429

120 loss: 0.0029888747

140 loss: 0.0029117232

160 loss: 0.0028402375

180 loss: 0.0027794265

200 loss: 0.0027436544

6.可视化
前5节内容的可视化代码下载链接: https://pan.baidu.com/s/1AbkH8hFo7Pg1dbcNgdWhwg 密码: 99ku

在下载文件visualization.py的同级目录下打开cmd。

运行命令：python visualization.py

可视化部分截图：





image.png

7.结论
1.这是本文作者写的第2篇关于tensorflow的文章，加深了对tensorflow框架的理解；

2.本文是作者学习《周莫烦tensorflow视频教程》的成果，感激前辈；

视频链接：https://morvanzhou.github.io/tutorials/machine-learning/tensorflow/

3.本文在周莫烦视频的基础上加入了自己的理解，add_layer函数修改为addConnect函数，本文作者认为更加贴切。

          
  

（一）基础铺垫
一元非线性回归分析（Univariate Nonlinear Regression）

在回归分析中，只包括一个自变量和一个因变量，且二者的关系可用一条曲线近似表示，则称为一元非线性回归分析。
一元二次方程：
一元三次方程：
一元 n 次方程：

（二）案例

1.建模逻辑

一元非线性回归方程转为多元一次回归方程



2.实操
关键点提示：把一元非线性方程转化为多元线性方程的方法

转化的方法是PolynomialFeatures类
要确定是一元几次方程（从图形中观察），然后确定degree是几（多少阶的方程）

#---author:朱元禄---
import pandas
data = pandas.read_csv(
    'file:///Users/apple/Desktop/jacky_1.csv',encoding='GBK'
)

x = data[["手续费（％）"]]
y = data[["金融产品销售额"]]

import matplotlib
font = {
    'family':'SimHei'
}
matplotlib.rc('font',**font)
matplotlib.rcParams['axes.unicode_minus'] = False
from pandas.plotting import scatter_matrix

scatter_matrix(
    data[["手续费（％）","金融产品销售额"]],
    alpha = 0.8,figsize =(10,10),diagonal = 'kid'
)

from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures

pf = PolynomialFeatures(degree=2)
x_2_fit = pf.fit_transform(x)

lrModel = LinearRegression()
lrModel.fit(x_2_fit,y)

lrModel.score(x_2_fit,y)

x_2_predict = pf.fit_transform([9],[10])
lrModel.predict(x_2_predict)


案例：游戏等级和木材消耗的关系。



首先导入数据集，取出自变量和因变量。
import pandas
import matplotlib;

data = pandas.read_csv(
    r'./data.csv'
)
#取出自变量和因变量
x = data[["等级"]]
y = data[["资源"]]




然后，绘制出两个变量之间的散点图：
import  pandas as  pd

pd.plotting.scatter_matrix(
    data[["等级", "资源"]],
    alpha=0.8, figsize=(10, 10), diagonal='kde'
)
plt.show()



可以看出是一元二次方程的曲线，我们画一个一元二次方程曲线来比较一下：
import numpy;
x_ = numpy.arange(-10, 10, 0.01);
y_ = x_**2

from matplotlib import pyplot as plt;

plt.figure();
plt.title('等级与资源')
plt.xlabel('等级')
plt.ylabel('资源')
plt.grid(True)
plt.plot(x_, y_, 'k.')
plt.show()




然后我们要将一元非线性回归方程转化为多元线性回归方程：

用到方法是PolynomialFeatures（）方法
# 导入包
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures


pf = PolynomialFeatures(degree=2)  #   传入degree参数，表示一元二次方程
x_2_fit = pf.fit_transform(x)
#查看x_2_fit：
print(x_2_fit)
'''
[[  1.   1.   1.]
 [  1.   2.   4.]
 [  1.   3.   9.]
 [  1.   4.  16.]
 [  1.   5.  25.]
 [  1.   6.  36.]
 [  1.   7.  49.]
 [  1.   8.  64.]
 [  1.   9.  81.]
 [  1.  10. 100.]
 [  1.  11. 121.]
 [  1.  12. 144.]]
'''

#然后就转换为二元线性回归方程了
lrModel = LinearRegression()
lrModel.fit(x_2_fit, y)  #训练模型
lrModel.score(x_2_fit, y)  #模型评分

x_2_predict = pf.fit_transform([[21], [22], [23]])   #预测的时候自变量需要经过转换再预测
lrModel.predict(x_2_predict)   #模型预测

print(lrModel.predict(x_2_predict))
'''
[[5028.38811189]
 [5515.18531469]
 [6025.57692308]]
'''

API总结：
一元n次方程，转多元线性回归方程：

pf = PolynomialFeatures(degree=2)

参数说明：
degree ：回归方程的次数

一元n次方程，转换为多元线性方程：

　　pf=sklearn.preprocessing.PolynomialFeatures(degree=2)

转换方法：

　　x_2_fit=pf.fit_trasform(x)

预测：

　　LinearRegression().predict(x_2_fit)

（一）基础铺垫

一元非线性回归分析（Univariate Nonlinear Regression）

在回归分析中，只包括一个自变量和一个因变量，且二者的关系可用一条曲线近似表示，则称为一元非线性回归分析。
一元二次方程：
y=a2x2+a1x1+a0x0
 
一元三次方程：
y=a3x3＋a2x2+a1x1+a0x0
 
一元 n 次方程：
y=anxn＋......+a1x1+a0x0
（二）案例－金融场景为例

产品编号
  
手续费（％）
  
金融产品销售额
1
  
2.2
  
25.5
2
  
2.3
  
22.5
3
  
2.4
  
19.5
4
  
2.5
  
16.5
5
  
2.7
  
13.5
6
  
3.1
  
10.5
7
  
3.6
  
7.5
8
  
4.8
  
4.5
9
  
7.0
  
1.5
1.建模逻辑

一元非线性回归方程转为多元一次回归方程
例如：y=a2x2+a1x1+a0x0
转为：y=a2x¯2+a1x¯1+a0x¯0
数据分析部落公众号（shujudata）
其中：
x¯0=x0
x¯1=x1
x¯2=x2
2.实操

jacky关键点提示：把一元非线性方程转化为多元线性方程的方法

转化的方法是PolynomialFeatures类
要确定是一元几次方程（从图形中观察），然后确定degree是几（多少阶的方程）
#---author:朱元禄---
import pandas
data = pandas.read_csv(
    'file:///Users/apple/Desktop/jacky_1.csv',encoding='GBK'
)

x = data[["手续费（％）"]]
y = data[["金融产品销售额"]]

import matplotlib
font = {
    'family':'SimHei'
}
matplotlib.rc('font',**font)
matplotlib.rcParams['axes.unicode_minus'] = False
from pandas.plotting import scatter_matrix

scatter_matrix(
    data[["手续费（％）","金融产品销售额"]],
    alpha = 0.8,figsize =(10,10),diagonal = 'kid'
)

from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures

pf = PolynomialFeatures(degree=2)
x_2_fit = pf.fit_transform(x)

lrModel = LinearRegression()
lrModel.fit(x_2_fit,y)

lrModel.score(x_2_fit,y)

x_2_predict = pf.fit_transform([9],[10])
lrModel.predict(x_2_predict)

python实现normal equation进行一元、多元线性回归
一元线性回归
数据
代码
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from sklearn.linear_model import SGDRegressor
from sklearn.preprocessing import StandardScaler
# 梯度下降
def gradientDecent(xmat,ymat):
sgd=SGDRegressor(max_iter=1000000, tol=1e-7)
sgd.fit(xmat,ymat)
return sgd.coef_,sgd.intercept_
# 导入数据
def loadDataSet(filename):
x=[[],[]]
y=[]
with open(filename,'r') as f:
for line in f.readlines():
lineDataList=line.split('\t')
lineDataList=[float(x) for x in lineDataList]
x[0].append(lineDataList[0])
x[1].append(lineDataList[1])
y.append(lineDataList[2])
return x,y
# 转化为矩阵
def mat(x):
return np.matrix(np.array(x)).T
# 可视化
def dataVisual(xmat,ymat,k,g,intercept):
k1,k2=k[0],k[1]
g1,g2=g[0],g[1]
matplotlib.rcParams['font.sans-serif'] = ['SimHei']
plt.title('拟合可视化')
plt.scatter(xmat[:,1].flatten().A[0],ymat[:,0].flatten().A[0])
x = np.linspace(0, 1, 50)
y=x*k2+k1
g=x*g2+g1+intercept
plt.plot(x,g,c='yellow')
plt.plot(x,y,c='r')
plt.show()
# 求解回归的参数
def normalEquation(xmat,ymat):
temp=xmat.T.dot(xmat)
isInverse=np.linalg.det(xmat.T.dot(xmat))
if isInverse==0.0:
print('不可逆矩阵')
else:
inv=temp.I
return inv.dot(xmat.T).dot(ymat)
# 主函数
def main():
xAll,y=loadDataSet('linearRegression/ex0.txt')
xlines=[]# 用于梯度下降算钱调用
for i in range(len(xAll[0])):
temp=[]
temp.append(xAll[0][i])
temp.append(xAll[1][i])
xlines.append(temp)
ylines=np.array(y).reshape(len(y),1)
# xlines=StandardScaler().fit_transform(xlines)
# ylines=StandardScaler().fit_transform(ylines)
# print(xlines)
# print(ylines)
gradPara,intercept=gradientDecent(xlines,y)
print('梯度下降参数')
print(gradPara)
print('梯度下降截距')
print(intercept)
xmat=mat(xAll)
ymat=mat(y)
print('normequation的参数:')
res=normalEquation(xmat,ymat)
print(res)
k1,k2=res[0,0],res[1,0]
dataVisual(xmat,ymat,[k1,k2],gradPara,intercept)
if __name__ == "__main__":
main()
结果
注意这里我踩了一个小小的坑，就是用SGDRegressor的时候，总是和预期结果相差一个截距，通过修改g从g=xg2+g1到g=xg2+g1+intercept，加上截距就好了
图中红色表示normalequation方法，而黄线表示梯度下降，由于我通过调参拟合的非常好，所以重合的很厉害，不好看出来
多元线性回归
数据
代码
import numpy as np
import matplotlib.pyplot as plt
import re
from sklearn.linear_model import SGDRegressor
# 将数据转化成为矩阵
def matrix(x):
return np.matrix(np.array(x)).T
# 线性函数
def linerfunc(xList,thList,*intercept):
res=0.0
for i in range(len(xList)):
res+=xList[i]*thList[i]
if len(intercept)==0:
return res
else:
return res+intercept[0][0]
# 加载数据
def loadData(fileName):
x=[]
y=[]
regex = re.compile('\s+')
with open(fileName,'r') as f:
readlines=f.readlines()
for line in readlines:
dataLine=regex.split(line)
dataList=[float(x) for x in dataLine[0:-1]]
xList=dataList[0:8]
x.append(xList)
y.append(dataList[-1])
return x,y
# 求解回归的参数
def normalEquation(xmat,ymat):
temp=xmat.T.dot(xmat)
isInverse=np.linalg.det(xmat.T.dot(xmat))
if isInverse==0.0:
print('不可逆矩阵')
return None
else:
inv=temp.I
return inv.dot(xmat.T).dot(ymat)
# 梯度下降求参数
def gradientDecent(xmat,ymat):
sgd=SGDRegressor(max_iter=1000000, tol=1e-7)
sgd.fit(xmat,ymat)
return sgd.coef_,sgd.intercept_
# 测试代码
def testTrainResult(normPara,gradPara,Interc,xTest,yTest):
nright=0
for i in range(len(xTest)):
if round(linerfunc(xTest[i],normPara)) ==yTest[i]:
nright+=1
print('关于normequation的预测方法正确率为 {}'.format(nright/len(xTest)))
gright=0
for i in range(len(xTest)):
if round(linerfunc(xTest[i],gradPara,Interc))==yTest[i]:
gright+=1
print('关于梯度下降法预测的正确率为 {}'.format(gright/len(xTest)))
# 运行程序
def main():
x,y=loadData('linearRegression/abalone1.txt')
# 划分训练集合和测试集
lr=0.8
xTrain=x[:int(len(x)*lr)]
yTrain=y[:int(len(y)*lr)]
xTest=x[int(len(x)*lr):]
yTest=y[int(len(y)*lr):]
xmat=matrix(xTrain).T
ymat=matrix(yTrain)
# 通过equation来计算模型的参数
theta=normalEquation(xmat,ymat)
print('通过equation来计算模型的参数')
theta=theta.reshape(1,len(theta)).tolist()[0]
print(theta)
# 掉包sklearn的梯度下降的算法求参数
print('掉包sklearn的梯度下降的算法求参数')
gtheta,Interc=gradientDecent(xTrain,yTrain)
print('参数')
print(gtheta)
print('截距')
print(Interc)
testTrainResult(theta,gtheta,Interc,xTest,yTest)
if __name__ == "__main__":
main()
结果
目录结构
数据下载