【Python机器学习及实践】进阶篇：Tensorflow框架

Python机器学习及实践——进阶篇：Tensorflow框架

Tensorflow内部有自己所定义的常量、变量、数据操作等要素。Tensorflow使用图（Graph）来表示计算任务；并使用会话（Session）来执行图。

---

使用Tensorflow输出一句话

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File  : TF01.py
@Author: Xinzhe.Pang
@Date  : 2019/7/26 22:00
@Desc  : 
"""
# 导入tensorflow工具包并命名为tf
import tensorflow as tf
import numpy as np

# 初始化一个Tensorflow的常量：Open the door of Tensorflow! 字符串，并命名为greeting作为一个计算模块
greeting = tf.constant('Open the door of Tensorflow!')

# 启动一个绘画
sess = tf.Session()

# 使用会话执行greeting计算模块
result = sess.run(greeting)

# 输出会话结果
print(result)
# 关闭会话
sess.close()

2019-07-26 22:03:13.411070: I tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX
2019-07-26 22:03:13.444048: I tensorflow/core/common_runtime/process_util.cc:71] Creating new thread pool with default inter op setting: 4. Tune using inter_op_parallelism_threads for best performance.
b'Open the door of Tensorflow!'

出现了两个警告信息，

解决方法：

• 如果安装的是GPU版本

如果你有一个GPU，你不应该关心AVX的支持，因为大多数昂贵的操作将被分派到一个GPU设备上（除非明确地设置）。在这种情况下，您可以简单地忽略此警告： 

import os 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

• 如果安装的是CPU版本（pip install tensorflow）

1.在代码中加入如下代码，忽略警告： 

import os 
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' 
2.编译TensorFlow源码 
如果您没有GPU并且希望尽可能多地利用CPU，那么如果您的CPU支持AVX，AVX2和FMA，则应该从针对CPU优化的源构建tensorflow。在这个问题中已经讨论过这个问题，也是这个GitHub问题。 Tensorflow使用称为bazel的ad-hoc构建系统，构建它并不是那么简单，但肯定是可行的。在此之后，不仅警告消失，tensorflow性能也应该改善。

---

使用Tensorflow完成一次线性函数的计算

Tensorflow如何像搭积木一样将各个不同的计算模块拼接成流程图，完成一次线性函数的计算，并在一个隐式会话中执行。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File  : TF02.py
@Author: Xinzhe.Pang
@Date  : 2019/7/26 22:21
@Desc  : 
"""
import tensorflow as tf
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

# 声明matrix1为Tensorflow的一个1*2的行向量
matrix1 = tf.constant([[3., 3.]])
# 声明matrix2为Tensorflow的一个2*1的列向量
matrix2 = tf.constant([[2.], [2.]])
# product将上述两个算子相乘，作为新算例
product = tf.matmul(matrix1, matrix2)

# 继续将product与一个标量2.0求和拼接，作为最终的linear算例
linear = tf.add(product, tf.constant(2.0))

# 直接在会话中执行linear算例，相当于将上面所有的单独算例拼接成流程图来执行
with tf.Session() as sess:
    result = sess.run(linear)
    print(result)

[[ 14.]]

---

使用Tensorflow自定义一个线性分类器用于对“良/恶性乳腺癌肿瘤”进行预测

Tensorflow允许使用者自由选择不同操作，并组织一个学习系统。

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File  : TF03.py
@Author: Xinzhe.Pang
@Date  : 2019/7/26 22:30
@Desc  : 
"""
import tensorflow as tf
import numpy as np
import pandas as pd
import os

os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
# 使用sklearn.model_selection里的train_test_split模块用于分割数据
from sklearn.model_selection import train_test_split

# 使用pandas读取乳腺肿瘤的训练和测试数据
# 创建特征列表
colnames = ['SampleNum', 'Clump Thickness', 'Cell Size', 'Cell Shape', 'Marginal Adhesion',
            'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin', 'Normal Nucleoli', 'Mitoses', 'Class']

# 使用pandas.read_csv函数从网络上读取指定数据
data = pd.read_csv(
    'https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data',
    names=colnames)
# 将？替换为标准缺失值表示
data = data.replace(to_replace='?', value=np.nan)
# 丢弃带有缺失值的数据（只要有一个维度有缺失）
data = data.dropna(how='any')

# 随机采样25%的数据用于测试，剩下的75%用于构建训练集合
train, test = train_test_split(data, test_size=0.25, random_state=33)

X_train = np.float32(train[['Clump Thickness', 'Cell Size']].T)
y_train = np.float32(train['Class'].T)
X_test = np.float32(test[['Clump Thickness', 'Cell Size']].T)
y_test = np.float32(test['Class'].T)

# 定义一个tensorflow的变量b作为线性模型的截距，同时设置初始值为1.0
b = tf.Variable(tf.zeros([1]))
# 定义一个tensorflow的变量W作为线性模型的系数，并设置初始值为-1.0至1.0之间均匀分布的随机数
W = tf.Variable(tf.random_uniform([1, 2], -1.0, 1.0))

# 显式地定义这个线性函数
y = tf.matmul(W, X_train) + b

# 使用tensorflow中的reduce_mean取得训练集上均方误差
loss = tf.reduce_mean(tf.square(y - y_train))

# 使用梯度下降法估计参数W,b，并且设置迭代步长为0.01,这个与Scikit-learn中的SGDRegressor类似
optimizer = tf.train.GradientDescentOptimizer(0.01)
# 以最小二乘损失为优化目标
train = optimizer.minimize(loss)

# 初始化所有变量
init = tf.global_variables_initializer()

# 开启Tensorflow中的会话
sess = tf.Session()

# 执行变量初始化操作
sess.run(init)

# 迭代1000轮次，训练参数
for step in range(0, 1000):
    sess.run(train)
    if step % 200 == 0:
        print(step, sess.run(W), sess.run(b))

# 准备测试样本
test_negative = test.loc[test['Class'] == 2][['Clump Thickness', 'Cell Size']]
test_positive = test.loc[test['Class'] == 4][['Clump Thickness', 'Cell Size']]

# 以最终更新的参数作图
import matplotlib.pyplot as plt

plt.scatter(test_negative['Clump Thickness'], test_negative['Cell Size'], marker='o', s=200, c='red')
plt.scatter(test_positive['Clump Thickness'], test_positive['Cell Size'], marker='x', s=150, c='black')

plt.xlabel('Clump Thickness')
plt.ylabel('Cell Size')

lx = np.arange(0, 12)

# 这里强调，以0.5作为分界面
ly = (0.5 - sess.run(b)) - lx * sess.run(W)[0][0] / sess.run(W)[0][1]

plt.plot(lx, ly, color='green')
plt.show()

WARNING:tensorflow:From D:\Anaconda3\lib\site-packages\tensorflow\python\framework\op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.
Instructions for updating:
Colocations handled automatically by placer.

未解决

WARNING:tensorflow:From D:\Anaconda3\lib\site-packages\tensorflow\python\util\tf_should_use.py:193: initialize_all_variables (from tensorflow.python.ops.variables) is deprecated and will be removed after 2017-03-02.
Instructions for updating:
Use `tf.global_variables_initializer` instead.

将tf.initialize_all_variables换成 global_variables_initializer

skflow非常适合那些熟悉于scikit-learn编程接口对使用者，而且利用Tensorflow的运算架构和模块，封装了许多经典的机器学习模型，如线性回归器、深度全连接的神经网络(DNN)等，推荐使用skflow；尽管如此，skflow仍然支持使用TensorFlow的基础算子来自定义学习流程，比如在自己搭建神经网络模型方面。

使用skflow内置的LinearRegreesor、DNN、以及scikit-learn中的集成回归模型对‘美国波士顿房价’进行回归预测

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
@File  : TF04.py
@Author: Xinzhe.Pang
@Date  : 2019/7/27 15:03
@Desc  : 
"""
from sklearn import datasets, metrics, preprocessing, model_selection

# 使用datasets.load_boston加载波士顿房价数据
boston = datasets.load_boston()

# 获取房屋数据特征以及对应房价
X, y = boston.data, boston.target
# 分割数据
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.25, random_state=33)

# 对数据特征进行标准化处理
scaler = preprocessing.StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 导入skflow
import skflow

# 使用skflow的LinearRegressor
tf_lr = skflow.TensorFlowLinearRegressor(steps=10000, learning_rate=0.01, batch_size=50)
tf_lr.fit(X_train, y_train)
tf_lr_y_pred = tf_lr.predict(X_test)

# 输出skflow中LinearRegressor模型的回归性能
print('The MAE of Tensorflow Linear Regressor on boston dataset is ', metrics.mean_absolute_error(tf_lr_y_pred, y_test))
print('The MSE of Tensorflow Linear Regressor on boston dataset is ', metrics.mean_squared_error(tf_lr_y_pred, y_test))
print('The R-squared value of Tensorflow Linear Regressor on boston dataset is ',
      metrics.r2_score(tf_lr_y_pred, y_test))

# 使用skflow的DNNRegressor，并且注意其每个隐层特征数量的配置
tf_dnn_regressor = skflow.TensorFlowDNNRegressor(hidden_units=[100, 40], steps=10000, learning_rate=0.01, batch_size=50)
tf_dnn_regressor.fit(X_train, y_train)
tf_dnn_regressor_y_pred = tf_dnn_regressor.predict(X_test)
# 输出skflow中DNNRegressor模型的回归性能
print('The MAE of Tensorflow DNNRegressor on boston dataset is ',
      metrics.mean_absolute_error(tf_dnn_regressor_y_pred, y_test))
print('The MSE of Tensorflow DNNRegressor on boston dataset is ',
      metrics.mean_squared_error(tf_dnn_regressor_y_pred, y_test))
print('The R-squared value of Tensorflow DNNRegressor on boston dataset is ',
      metrics.r2_score(tf_dnn_regressor_y_pred, y_test))

# 使用Scikit-learn的RandomForestRegressor
from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor()
rfr.fit(X_train, y_train)
rfr_y_pred = rfr.predict(X_test)

# 输出Scikit-learn的RandomForestRegressor模型的回归性能
print('The MAE of Sklearn RandomForestRegressor on boston dataset is ',
      metrics.mean_absolute_error(rfr_y_pred, y_test))
print('The MSE of Sklearn RandomForestRegressor on boston dataset is ',
      metrics.mean_squared_error(rfr_y_pred, y_test))
print('The R-squared value of Sklearn RandomForestRegressor on boston dataset is ',
      metrics.r2_score(rfr_y_pred, y_test))

通过上述一系列的输出可知，深度神经网络可以表现处更高的性能，不过需注意的是，越是具备描述复杂数据的强力模型， #越容易在训练时陷入过拟合，这一点需要在配置DNN的层数和每层特征元的数量时特别注意。