1. 认识TensorFlow
2. 概念
第二行：b就是w0，Variable是变量的意思
第三行：unniform是范围是-1到+1之间的均匀分布，w是784行，100列的数据
第四行：占位，占了个空，未来有数据可以填进去
第五行：relu是一个函数，<0的时候就是0，>0的时候是x，如下图
matmul就是矩阵相乘，w乘x
3. 代码
TensorFlow程序可以通过tf.device函数来指定运行每一个操作的设备。
这个设备可以是本地的CPU或者GPU，也可以是某一台远程的服务器。
TensorFlow会给每一个可用的设备一个名称，tf.device函数可以通过设备的名称，来指定执行运算的设备。比如CPU在TensorFlow中的名称为/cpu:0。
在默认情况下，即使机器有多个CPU，TensorFlow也不会区分它们，所有的CPU都使用/cpu:0作为名称。
–而一台机器上不同GPU的名称是不同的，第n个GPU在TensorFlow中的名称为/gpu:n。
–比如第一个GPU的名称为/gpu:0，第二个GPU名称为/gpu:1，以此类推。
–TensorFlow提供了一个快捷的方式，来查看运行每一个运算的设备。
–在生成会话时，可以通过设置log_device_placement参数来打印运行每一个运算的设备。
–除了可以看到最后的计算结果之外，还可以看到类似“add: /job:localhost/replica:0/task:0/cpu:0”这样的输出
–这些输出显示了执行每一个运算的设备。比如加法操作add是通过CPU来运行的，因为它的设备名称中包含了/cpu:0。
–在配置好GPU环境的TensorFlow中，如果操作没有明确地指定运行设备，那么TensorFlow会优先选择GPU
TensorFlow程序会典型的分为两部分，第一部分是创建计算图，叫做构建阶段，
这一阶段通常建立表示机器学习模型的的计算图，和需要去训练模型的计算图，
第二部分是执行阶段，执行阶段通常运行Loop循环重复训练步骤，每一步训练小批量数据，
逐渐的改进模型参数
- 简单的一个流程代码：
import tensorflow as tf
# tf.Variable生成的变量，每次迭代都会变化，
# 这个变量也就是我们要去计算的结果，所以说你要计算什么，你是不是就把什么定义为Variable
# with里面的语句在cpu执行
with tf.device('/cpu:0'):
x = tf.Variable(3, name='x') # 初始值为3的变量
# 跳出with后回到默认的设备里执行
y = tf.Variable(4, name='y')
f = x * x * y + y + 2 #随便定义一个计算逻辑，f不会i一个结果，是一个Tensor对象，就是所谓的结点
print(f)
# 创建一个计算图的一个上下文环境
# 配置里面是把具体运行过程在哪里执行给打印出来,可不加
sess = tf.Session(config=tf.ConfigProto(log_device_placement=True))
# 碰到session.run()就会立刻去调用计算
# 这行代码干的事情就是把3赋给x
sess.run(x.initializer) # initializer是一个函数，这里没有()，说明十八这个函数交给上下文取执行里
sess.run(y.initializer)
result = sess.run(f)
print(result)
sess.close()
红色的是具体运行过程在哪里执行
上述代码的简化版：
import tensorflow as tf
x = tf.Variable(3, name='x')
y = tf.Variable(4, name='y')
f = x*x*y + y + 2
# 在with块内部，session被设置为默认的session
with tf.Session() as sess:
x.initializer.run() # 等价于 tf.get_default_session().run(x.initializer)
y.initializer.run()
result = f.eval() # 等价于 tf.get_default_session().run(f)
print(result)
再次改进：每个变量都初始化，太麻烦了，用一个函数把所有变量初始化
import tensorflow as tf
x = tf.Variable(3, name='x')
y = tf.Variable(4, name='y')
f = x*x*y + y + 2
# 可以不分别对每个变量去进行初始化
# 并不立即初始化，在run运行的时候才初始化
init = tf.global_variables_initializer()
with tf.Session() as sess:
init.run()
result = f.eval()
print(result)
用InteractiveSession：
import tensorflow as tf
x = tf.Variable(3, name='x')
y = tf.Variable(4, name='y')
f = x*x*y + y + 2
init = tf.global_variables_initializer()
# InteractiveSession和常规的Session不同在于，自动默认设置它自己为默认的session
# 即无需放在with块中了，但是这样需要自己来close session
sess = tf.InteractiveSession()
init.run()
result = f.eval()
print(result)
sess.close()
# TensorFlow程序会典型的分为两部分，第一部分是创建计算图，叫做构建阶段，
# 这一阶段通常建立表示机器学习模型的的计算图，和需要去训练模型的计算图，
# 第二部分是执行阶段，执行阶段通常运行Loop循环重复训练步骤，每一步训练小批量数据，
# 逐渐的改进模型参数
- 管理图：
import tensorflow as tf
# 任何创建的节点会自动加入到默认的图
x1 = tf.Variable(1)
print(x1.graph is tf.get_default_graph())
# 大多数情况下上面运行的很好，有时候或许想要管理多个独立的图
# 可以创建一个新的图并且临时使用with块是的它成为默认的图
graph = tf.Graph()
x3 = tf.Variable(3)
with graph.as_default():
x2 = tf.Variable(2)
x4 = tf.Variable(4) # 已经跳出with了，所以会加到默认图中
print(x2.graph is graph)
print(x2.graph is tf.get_default_graph())
print(x3.graph is tf.get_default_graph())
print(x3.graph is tf.get_default_graph())
3. 生命周期：
import tensorflow as tf
# 当去计算一个节点的时候，TensorFlow自动计算它依赖的一组节点，并且首先计算依赖的节点
w = tf.constant(3) # 常量，不会变
x = w + 2
y = x + 5
z = x * 3
# 上面这个形成一种依赖，要算z就得先算x，要知道x就得先算w
with tf.Session() as sess:
print(y.eval())
# 这里为了去计算z，又重新计算了x和w，除了Variable值，tf是不会缓存其他比如contant等的值的
# 一个Variable的生命周期是当它的initializer运行的时候开始，到会话session close的时候结束
print(z.eval())
# 如果我们想要有效的计算y和z，并且又不重复计算w和x两次，我们必须要求TensorFlow计算y和z在一个图里
with tf.Session() as sess:
y_val, z_val = sess.run([y, z])
print(y_val)
print(z_val)
- 用解析解实现线性回归：
import tensorflow as tf
import numpy as np
from sklearn.datasets import fetch_california_housing
# 立刻下载数据集
housing = fetch_california_housing(data_home="./", download_if_missing=True)
# 获得X数据行数和列数
m, n = housing.data.shape
# 这里添加一个额外的bias输入特征(x0=1)到所有的训练数据上面，因为使用的numpy所有会立即执行
housing_data_plus_bias = np.c_[np.ones((m, 1)), housing.data]
# 创建两个TensorFlow常量节点X和y，去持有数据和标签
X = tf.constant(housing_data_plus_bias, dtype=tf.float32, name='X')
y = tf.constant(housing.target.reshape(-1, 1), dtype=tf.float32, name='y')
# 使用一些TensorFlow框架提供的矩阵操作去求theta
XT = tf.transpose(X)
# 解析解一步计算出最优解,matrix_inverse是求逆，也就是求-1次方
theta = tf.matmul(tf.matmul(tf.matrix_inverse(tf.matmul(XT, X)), XT), y)
with tf.Session() as sess:
theta_value = theta.eval() # sess.run(theta)
print(theta_value)
- 梯度下降实现线性回归：
import tensorflow as tf
import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import StandardScaler
n_epochs = 10000
learning_rate = 0.01
housing = fetch_california_housing()
m, n = housing.data.shape
housing_data_plus_bias = np.c_[np.ones((m, 1)), housing.data]
# 可以使用TensorFlow或者Numpy或者sklearn的StandardScaler去进行归一化
# StandardScaler默认就做了方差归一化，和均值归一化，这两个归一化的目的都是为了更快的进行梯度下降
# 你如何构建你的训练集，你训练除了的模型，就具备什么样的功能！
scaler = StandardScaler().fit(housing_data_plus_bias)
scaled_housing_data_plus_bias = scaler.transform(housing_data_plus_bias)
X = tf.constant(scaled_housing_data_plus_bias, dtype=tf.float32, name='X')
y = tf.constant(housing.target.reshape(-1, 1), dtype=tf.float32, name='y')
# random_uniform函数创建图里一个节点包含随机数值，给定它的形状和取值范围，就像numpy里面rand()函数
theta = tf.Variable(tf.random_uniform([n + 1, 1], -1.0, 1.0), name='theta')
y_pred = tf.matmul(X, theta, name="predictions")
error = y_pred - y
# square是平方，reduce_mean加和求平均
mse = tf.reduce_mean(tf.square(error), name="mse")
# 梯度的公式：(y_pred - y) * xj，transpose是转置
gradients = 2/m * tf.matmul(tf.transpose(X), error)
# tf自动实现梯度，之前我们知道，梯度咱们用公式是推导出来的，这里也是，tf自动求导，自己推导出来的
# gradients = tf.gradients(mse, [theta])[0]
# 赋值函数对于BGD来说就是 theta_new = theta - (learning_rate * gradients)；assign是赋值
training_op = tf.assign(theta, theta - learning_rate * gradients)
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
for epoch in range(n_epochs):
if epoch % 100 == 0:
print("Epoch", epoch, "MSE = ", mse.eval())
sess.run(training_op)
best_theta = theta.eval()
print(best_theta)
升级：梯度和梯度下降也不用自己实现，用tf的优化器实现
import tensorflow as tf
import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.preprocessing import StandardScaler
# TensorFlow为我们去计算梯度，但是同时也给了我们更方便的求解方式
# 它提供给我们与众不同的，有创意的一些优化器，包括梯度下降优化器
# 替换前面代码相应的行，并且一切工作正常
# 设定超参数，Grid Search进行栅格搜索，其实说白了就是排列组合找到Loss Function最小的时刻
# 的那组超参数结果
n_epochs = 1000
learning_rate = 0.01
# 读取数据，这里读取数据是一下子就把所有数据交给X，Y节点，所以下面去做梯度下降的时候
# BGD = Batch Gradient Decrease ，如果面向数据集比较大的时候，我们倾向与 Mini GD
housing = fetch_california_housing()
m, n = housing.data.shape
housing_data_plus_bias = np.c_[np.ones((m, 1)), housing.data]
# 可以使用TensorFlow或者Numpy或者sklearn的StandardScaler去进行归一化
scaler = StandardScaler().fit(housing_data_plus_bias)
scaled_housing_data_plus_bias = scaler.transform(housing_data_plus_bias)
# 下面部分X，Y最后用placeholder可以改成使用Mini BGD
# 构建计算的图
X = tf.constant(scaled_housing_data_plus_bias, dtype=tf.float32, name='X')
y = tf.constant(housing.target.reshape(-1, 1), dtype=tf.float32, name='y')
# random_uniform函数创建图里一个节点包含随机数值，给定它的形状和取值范围，就像numpy里面rand()函数
theta = tf.Variable(tf.random_uniform([n + 1, 1], -1.0, 1.0), name='theta')
y_pred = tf.matmul(X, theta, name="predictions")
error = y_pred - y
mse = tf.reduce_mean(tf.square(error), name="mse")
# 梯度的公式：(y_pred - y) * xj
# gradients = 2/m * tf.matmul(tf.transpose(X), error)
# gradients = tf.gradients(mse, [theta])[0]
# 赋值函数对于BGD来说就是 theta_new = theta - (learning_rate * gradients)
# training_op = tf.assign(theta, theta - learning_rate * gradients)
optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
# MomentumOptimizer收敛会比梯度下降更快
# optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.9)
training_op = optimizer.minimize(mse)
init = tf.global_variables_initializer()
# 下面是开始训练
with tf.Session() as sess:
sess.run(init)
for epoch in range(n_epochs):
if epoch % 100 == 0:
print("Epoch", epoch, "MSE = ", mse.eval())
sess.run(training_op)
best_theta = theta.eval()
print(best_theta)
# 最后还要进行模型的测试，防止过拟合
3770
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
