感谢中国人民大学胡鹤老师,课讲得非常好~

首先,何谓tensor?即高维向量,例如矩阵是二维,tensor是更广义意义上的n维向量(有type+shape)

TensorFlow执行过程为定义图,其中定义子节点,计算时只计算所需节点所依赖的节点,是一种高效且适应大规模的数据计算,方便分布式设计,对于复杂神经网络的计算,可将其拆开到其他核中同时计算。

Theano——torch———caffe(尤其是图像处理)——deeplearning5j——H20——MXNet,TensorFlow

运行环境

下载docker

打开docker quickstart terminal

标红地方显示该docker虚拟机IP地址(即之后的localhost)

docker tensorflow/tensorflow  //自动找到TensorFlow容器并下载

docker images  //浏览当前容器

docker run -p 8888:8888 tensorflow/tensorflow  //在8888端口运行

会出现一个token,复制该链接并替换掉localhost,既可以打开TensorFlow的一个编写器,jupyter

大体雏形

  1. #python导入
  2. import tensorflow as tf
  3. #定义变量(节点)
  4. x = tf.Variable(3, name="x")
  5. y = tf.Variable(4, name="y")
  6. f = x*x*y + y + 2
  7. #定义session
  8. sess = tf.Session()
  9. #为已经定义的节点赋值
  10. sess.run(x.initializer)
  11. sess.run(y.initializer)
  12. #运行session
  13. result = sess.run(f)
  14. print(result) #
  15. #释放空间
  16. sess.close

还有一个更简洁的一种定义并运行session方法

  1. # a better way
  2. with tf.Session() as sess:
  3. x.initializer.run()
  4. y.initializer.run()
  5. #即evaluate,求解f的值
  6. result = f.eval()

初始化的两行也可以写作

init = tf.global_variables_initializer()

init.run()

而session可以改作sess=tf.InteractiveSession()运行起来更方便

  1. init = tf.global_variables_initializer()
  2. sess = tf.InteractiveSession()
  3. init.run()
  4. result = f.eval()
  5. print(result)

因而TensorFlow的代码分为两部分,定义部分和执行部分

TensorFlow是一个图的操作,有自动缺省的默认图和你自己定义的图

  1. #系统默认缺省的图
  2. >>> x1 = tf.Variable(1)
  3. >>> x1.graph is tf.get_default_graph()
  4. True
  5. #自定义的图
  6. >>> graph = tf.Graph()
  7. >>> with graph.as_default():
  8. x2 = tf.Variable(2)
  9. >>> x2.graph is graph
  10. True
  11. >>> x2.graph is tf.get_default_graph()
  12. False

节点的生命周期

第二种方法可以找出公共部分,避免x被计算2次。

运行结束后所有节点的值都被清空,如果没有单独保存,还需重新run一遍。

  1. w = tf.constant(3)
  2. x = w + 2
  3. y = x + 5
  4. z = x * 3
  5. with tf.Session() as sess:
  6. print(y.eval()) #
  7. print(z.eval()) #
  8.  
  9. with tf.Session() as sess:
  10. y_val, z_val = sess.run([y, z])
  11. print(y_val) #
  12. print(z_val) #

Linear Regression with TensorFlow(线性回归上的应用)

y = wx+b = wx'  //这里x'是相较于x多了一维全是1的向量

这里引用California housing的数据

TensorFlow上向量是列向量,需要reshape(-1,1)即转置成列向量

使用normal equation方法求解

  1. import numpy as np
  2. from sklearn.datasets import fetch_california_housing
  3. housing = fetch_california_housing()
  4. #获得数据维度,矩阵的行列长度
  5. m, n = housing.data.shape
  6. #np.c_是连接的含义,加了一个全为1的维度
  7. housing_data_plus_bias = np.c_[np.ones((m, 1)), housing.data]
  8. #数据量并不大,可以直接用常量节点装载进来,但是之后海量数据无法使用(会用minbatch的方式导入数据)
  9. X = tf.constant(housing_data_plus_bias, dtype=tf.float32, name="X")
  10. #转置成列向量
  11. y = tf.constant(housing.target.reshape(-1, 1), dtype=tf.float32, name="y")
  12. XT = tf.transpose(X)
  13. #使用normal equation的方法求解theta,之前线性模型中有提及
  14. theta = tf.matmul(tf.matmul(tf.matrix_inverse(tf.matmul(XT, X)), XT), y)
  15. #求出权重
  16. with tf.Session() as sess:
  17. theta_value = theta.eval()

如果是原本的方法,可能更直接些。但由于使用底层的库不同,它们计算出来的值不完全相同。

  1. #使用numpy
  2. X = housing_data_plus_bias
  3. y = housing.target.reshape(-1, 1)
  4. theta_numpy = np.linalg.inv(X.T.dot(X)).dot(X.T).dot(y)
  5. #使用sklearn
  6. from sklearn.linear_model import LinearRegression
  7. lin_reg = LinearRegression()
  8. lin_reg.fit(housing.data, housing.target.reshape(-1, 1))

这里不禁感到疑惑,为什么TensorFlow感觉变复杂了呢?其实,这不过因为这里数据规模较小,进行大规模的计算时,TensorFlow的自动优化所发挥的效果,是十分厉害的。

使用gradient descent(梯度下降)方法求解

  1. #使用gradient时需要scale一下
  2. from sklearn.preprocessing import StandardScaler
  3. scaler = StandardScaler()
  4. scaled_housing_data = scaler.fit_transform(housing.data)
  5. scaled_housing_data_plus_bias = np.c_[np.ones((m, 1)), scaled_housing_data]
  6. #迭代1000次
  7. n_epochs = 1000
  8. learning_rate = 0.01
  9. #由于使用gradient,写入x的值需要scale一下
  10. X = tf.constant(scaled_housing_data_plus_bias, dtype=tf.float32, name="X")
  11. y = tf.constant(housing.target.reshape(-1, 1), dtype=tf.float32, name="y")
  12. #使用gradient需要有一个初值
  13. theta = tf.Variable(tf.random_uniform([n + 1, 1], -1.0, 1.0), name="theta")
  14. #当前预测的y,x是m*(n+1),theta是(n+1)*1,刚好是y的维度
  15. y_pred = tf.matmul(X, theta, name="predictions")
  16. #整体误差
  17. error = y_pred - y
  18. #TensorFlow求解均值功能强大,可以指定维数,也可以像下面方法求整体的
  19. mse = tf.reduce_mean(tf.square(error), name="mse")
  20. #暂时自己写出训练过程,实际可以采用TensorFlow自带的功能更强大的自动求解autodiff方法
  21. gradients = 2/m * tf.matmul(tf.transpose(X), error)
  22. training_op = tf.assign(theta, theta - learning_rate * gradients)
  23. #初始化并开始求解
  24. init = tf.global_variables_initializer()
  25. with tf.Session() as sess:
  26. sess.run(init)
  27. for epoch in range(n_epochs):
  28. #每运行100次打印一下当前平均误差
  29. if epoch % 100 == 0:
  30. print("Epoch", epoch, "MSE =", mse.eval())
  31. sess.run(training_op)
  32. best_theta = theta.eval()

上述代码中的autodiff如下,可以自动求出gradient

  1. gradients = tf.gradients(mse, [theta])[0]

使用Optimizer

上述的整个梯度下降和迭代方法,都封装了在如下方法中

optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)

training_op = optimizer.minimize(mse)

这样的optimizer还有很多

例如带冲量的optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate,momentum=0.9)

Feeding data to training algorithm

当数据量达到几G,几十G时,使用constant直接导入数据显然是不现实的,因而我们用placeholder做一个占位符

(一般行都是none,即数据量是任意的)

真正运行,run的时候再feed数据。可以不断使用新的数据。

  1. >>> A = tf.placeholder(tf.float32, shape=(None, 3))
  2. >>> B = A + 5
  3. >>> with tf.Session() as sess:
  4. ... B_val_1 = B.eval(feed_dict={A: [[1, 2, 3]]})
  5. ... B_val_2 = B.eval(feed_dict={A: [[4, 5, 6], [7, 8, 9]]})
  6. ...
  7. >>> print(B_val_1)
  8. [[ 6. 7. 8.]]
  9. >>> print(B_val_2)
  10. [[ 9. 10. 11.]
  11. [ 12. 13. 14.]]

这样,就可以通过定义min_batch来分批次随机抽取指定数量的数据,即便是几T的数据也可以抽取。

  1. batch_size = 100
  2. n_batches = int(np.ceil(m / batch_size))
  3. #有放回的随机抽取数据
  4. def fetch_batch(epoch, batch_index, batch_size):
  5. #定义一个随机种子
  6. np.random.seed(epoch * n_batches + batch_index) # not shown in the book
  7. indices = np.random.randint(m, size=batch_size) # not shown
  8. X_batch = scaled_housing_data_plus_bias[indices] # not shown
  9. y_batch = housing.target.reshape(-1, 1)[indices] # not shown
  10. return X_batch, y_batch
  11. #开始运行
  12. with tf.Session() as sess:
  13. sess.run(init)
  14. #每次都抽取新的数据做训练
  15. for epoch in range(n_epochs):
  16. for batch_index in range(n_batches):
  17. X_batch, y_batch = fetch_batch(epoch, batch_index, batch_size)
  18. sess.run(training_op, feed_dict={X: X_batch, y: y_batch})
  19. #最终结果
  20. best_theta = theta.eval()

Saving and Restoring models(保存模型)

有时候,运行几天的模型可能因故暂时无法继续跑下去,因而需要暂时保持已训练好的部分模型到硬盘上。

  1. init = tf.global_variables_initializer()
  2. saver = tf.train.Saver()
  3. #保存模型
  4. with tf.Session() as sess:
  5. sess.run(init)
  6.  
  7. for epoch in range(n_epochs):
  8. if epoch % 100 == 0:
  9. #print("Epoch", epoch, "MSE =", mse.eval())
  10. save_path = saver.save(sess, "/tmp/my_model.ckpt")
  11. sess.run(training_op)
  12.  
  13. best_theta = theta.eval()
  14. save_path = saver.save(sess, "/tmp/my_model_final.ckpt")
  1. #恢复模型
  2. with tf.Session() as sess:
  3. saver.restore(sess, "/tmp/my_model_final.ckpt")
  4. best_theta_restored = theta.eval()

关于TensorBoard

众所周知,神经网络和机器学习大多是黑盒模型,让人有点忐忑。TensorBoard所起的功能就是将这个黑盒稍微变白一些~

启用tensorboard

输入docker ps查看当前容器id

进入容器

使用tensorboard --log-dir=tf_logs命令打开已经存入的tf_logs文件,其生成代码如下所示

  1. from datetime import datetime
  2.  
  3. now = datetime.utcnow().strftime("%Y%m%d%H%M%S")
  4. root_logdir = "tf_logs"
  5. logdir = "{}/run-{}/".format(root_logdir, now)
  6. ...
  7. mse_summary = tf.summary.scalar('MSE', mse)
  8. file_writer = tf.summary.FileWriter(logdir, tf.get_default_graph())
  9. ...
  10. if batch_index % 10 == 0:
  11. summary_str = mse_summary.eval(feed_dict={X: X_batch, y: y_batch})
  12. step = epoch * n_batches + batch_index
  13. file_writer.add_summary(summary_str, step)

【机器学习】TensorFlow学习(一)的更多相关文章

  1. TensorFlow机器学习框架-学习笔记-001

    # TensorFlow机器学习框架-学习笔记-001 ### 测试TensorFlow环境是否安装完成-----------------------------```import tensorflo ...

  2. 人工智能新手入门学习路线和学习资源合集(含AI综述/python/机器学习/深度学习/tensorflow)

    [说在前面]本人博客新手一枚,象牙塔的老白,职业场的小白.以下内容仅为个人见解,欢迎批评指正,不喜勿喷![握手][握手] 1. 分享个人对于人工智能领域的算法综述:如果你想开始学习算法,不妨先了解人工 ...

  3. Tensorflow学习笔记2019.01.22

    tensorflow学习笔记2 edit by Strangewx 2019.01.04 4.1 机器学习基础 4.1.1 一般结构: 初始化模型参数:通常随机赋值,简单模型赋值0 训练数据:一般打乱 ...

  4. Tensorflow学习笔记2019.01.03

    tensorflow学习笔记: 3.2 Tensorflow中定义数据流图 张量知识矩阵的一个超集. 超集:如果一个集合S2中的每一个元素都在集合S1中,且集合S1中可能包含S2中没有的元素,则集合S ...

  5. TensorFlow学习笔记之--[compute_gradients和apply_gradients原理浅析]

    I optimizer.minimize(loss, var_list) 我们都知道,TensorFlow为我们提供了丰富的优化函数,例如GradientDescentOptimizer.这个方法会自 ...

  6. 机器学习&深度学习基础(目录)

    从业这么久了,做了很多项目,一直对机器学习的基础课程鄙视已久,现在回头看来,系统的基础知识整理对我现在思路的整理很有利,写完这个基础篇,开始把AI+cv的也总结完,然后把这么多年做的项目再写好总结. ...

  7. TensorFlow学习路径【转】

    作者:黄璞链接:https://www.zhihu.com/question/41667903/answer/109611087来源:知乎著作权归作者所有.商业转载请联系作者获得授权,非商业转载请注明 ...

  8. TensorFlow学习线路

    如何高效的学习 TensorFlow 代码? 或者如何掌握TensorFlow,应用到任何领域? 作者:黄璞链接:https://www.zhihu.com/question/41667903/ans ...

  9. 深度学习-tensorflow学习笔记(1)-MNIST手写字体识别预备知识

    深度学习-tensorflow学习笔记(1)-MNIST手写字体识别预备知识 在tf第一个例子的时候需要很多预备知识. tf基本知识 香农熵 交叉熵代价函数cross-entropy 卷积神经网络 s ...

  10. tensorflow学习笔记(2)-反向传播

    tensorflow学习笔记(2)-反向传播 反向传播是为了训练模型参数,在所有参数上使用梯度下降,让NN模型在的损失函数最小 损失函数:学过机器学习logistic回归都知道损失函数-就是预测值和真 ...

随机推荐

  1. python---os模块使用详解

    os模块调用操作系统接口的模块 相关方法或属性: getcwd() --- 获取当前的操作目录,等同于linux中的pwd命令. 调用:os.getcwd() chdir() --- 改变python ...

  2. 如何科学地蹭热点:用python爬虫获取热门微博评论并进行情感分析

    前言:本文主要涉及知识点包括新浪微博爬虫.python对数据库的简单读写.简单的列表数据去重.简单的自然语言处理(snowNLP模块.机器学习).适合有一定编程基础,并对python有所了解的盆友阅读 ...

  3. C# 如何添加Word文本和图片超链接

    超链接简单来讲就是内容链接,通过设置超链接可以实现对象与网页.站点之间的连接.链接目标可以是网页.图片.邮件地址.文件夹或者是应用程序.设置链接的对象可以是文本或者图片. 在以下内容中,我将介绍如何用 ...

  4. cmd启动,重启,停止IIS命令

    直接使用CMD我们可以操作很多事情,比如启动IIS,重启IIS,停止IIS 重启IIS服务器,开始->运行->cmd (以下列出相关操作命令): iisreset /RESTART 停止后 ...

  5. Android 屏幕相关概念(1)

    1.  术语和概念 术语 说明 备注  Screen size(屏幕尺寸)  指的是手机实际的物理尺寸,比如常用的2.8英寸,3.2英寸,3.5英寸,3.7英寸  摩托罗拉milestone手机是3. ...

  6. http服务详解(1)——一次完整的http服务请求处理过程

    前言:要熟练掌握一个服务,首先需要非常了解这个服务的工作过程,这篇就详细解释了http服务的请求处理过程. 一次完整的http请求处理过程 (1)流程图 (2)过程详解 0.DNS域名解析:递归查询. ...

  7. YYHS-string(线段树)

    题解 这道题给你两个操作,一个升序,一个降序 我们可以观察到这个字符串都是由小写字母组成的,只有26个字符,所以我们开一个26个字符的线段树 每次查询的时候找到这个区间内'a'到'z'的数量,再判断一 ...

  8. Linux入门(5)——Ubuntu16.04安装网易云音乐

    去网易云音乐官网下载deb包: http://music.163.com/#/download 打开终端: cd 下载 .0_amd64_ubuntu16..deb sudo apt-get -f i ...

  9. java传值与传引用总结

    基本数据类型 我们先来看一个代码 public class ParamTest { public static void main(String[] arge) { double percent = ...

  10. MySql sql按时间分组

    select DATE_FORMAT(f.upload_time,'%Y%u') weeks,count(*),sum(p.download_times),sum(p.collection_times ...