【MR_jiang】TF学习笔记总结记录


#1

加入datageekers第一天,坚持、加油。脚踏实地,静待收获的那一天


#2

Week 1 预习作业 话不多说,直接上code: :grin:

  • test one import tensorflow as tf
   x = tf.constant(2.0) # x = 2
   y = tf.constant(3.0) # y = 3
   z = tf.constant(7.0) # z = 7

   xy_mul = tf.multiply(x, y) # xy_mul = x * y
   res = tf.add(xy_mul, z)  # res = x * y + z
   with tf.Session() as sess :
      ans = sess.run(res)
   print(ans)

RESULT: 13.0

  • test two
    import tensorflow as tf
    matrix1 = tf.constant([[3., 3.]])
    matrix2 = tf.constant([[2.], [2.]])
    result = tf.matmul(matrix1, matrix2)
    with tf.Session() as sess :
       ans_1 = sess.run(result)
    print(ans_1)

RESULT: [[ 12.]]


#3

加油,等到学有所成的那一天,推荐你们去更好的平台发展~~:grinning:


#4

坚持到底,会有新的感悟与收获,加油


#5

【week 1理论学习问题】 1、机器学习中,监督学习 or 非监督学习概念区分,应用场景调研? 个人理解(尽量一句话解释)

监督学习(Supervised Learning):  存在大量已知数据/Label,通过构建相关模型,当
有一个新数据传入时,运用已知模型判断新数据Label.
非监督学习(Unsupervised Learning): 和监督学习的区别在于,所给数据没有给定
相关label,通过相关算法,可以对已给的未知数据进行区分、归类。

2、做机器学习项目,有哪些环节?

分析项目,将其抽象为数学问题->获取数据->特征预处理与特征选择->训练模型与调优->
模型诊断->模型融合->上线运行。

3、深度学习,目前有哪些应用领域?

Deep learning在语音、图像、自然语言处理等等领域中取得了巨大的成功。

4、数据预处理,需要注意哪些?

特征预处理、数据清洗是很关键的步骤,往往能够使得算法的效果和性能得到显著提高。归一化
、离散化、因子化、缺失值处理、去除共线性等重要步骤对接下来的步骤具有重要的帮助作用。

5、tensorflow运行原理,架构有哪些核心点?

tensorflow是谷歌开源的深度学习框架,其使用的核心点在于在每次计算运行之前,都会生成
一个计算图,图里面包括了tensor(张量)、operation(算子)、kernel、edge(边)、
session(回话)等诸多结构,这个结构统一协作,实现出想要进行的操作和结果。

#6

总结的非常赞,加油~


#7

一、back propagation 算法原理理解 ?

1、为什么要使用后向传播?

以简单3层MLP为例,通常其基本架构为 :

与后向传播相对应的前向传播框图大概是: 数据输入(x(i),y(i)) -> 线性组合$\Theta ^{T}*x$ ``` -> 激活函数 (sigmoid)-> 输出(output)

假设现在根据前向传播的框图得到了一个output function,但是我们怎么判断这个函数就是 我们想要的、具有优良特性的最终函数呢?为了判定这个问题,这就引出了损失函数的概念,通 过最小化损失函数J($\theta$)来让预测值 $\hat{y}$ 尽可能的贴合实际值y。 而使用后向传 播算法就是为了更新在最小化损失函数时的参数。

2、bp算法的推导。 公式太多,暂略,嘻嘻(●'◡'●) 3、bp算法的问题。 根据人工智能的奠基人Hinton所说,之所以我们现在的机器学习还不能称为仿人脑的人工智能,有很大的原因就是,我们现在没有任何神经学的理论告诉我们说我们的大脑里有这种bp算法的存在,这个问题的存在甚至可能会直接颠覆掉人工智能这么多年的发展。

二、sigmoid函数、tanh函数和ReLU函数的区别?以及各自的优缺点?对应的 tf函数是? 1、 Sigmoid 非线性函数将输入映射到$ \left( 0,1\right) $ 之间。它的数学公式为:$\sigma \left( x\right) =\dfrac {1} {1+e^{-x}}$ 对应的tensorflow函数: tf.nn.sigmoid() 缺点: 1 容易出现梯度消失或梯度饱和的情况。 2 sigmoid函数不是关于原点对称的

2、tanh函数同样存在饱和问题, 但它的输出是零中心的,因此实际中 tanh 比 sigmoid 更受欢迎。 tanh 函数实际上是一个放大的 sigmoid 函数,数学关系为:$\tanh \left( x\right) =2\sigma \left( 2x\right) -1$

对应的tensorflow函数: tf.nn.tanh()

3、ReLU ,它的数学公式为:$f\left( x\right) =\max \left( 0,x\right) $

相较于 sigmoid 和 tanh 函数, ReLU 对于 SGD 的收敛有巨大的加速作用,有人认为这是由它的线性、非饱和的公式导致的。```

```对应的tensorflow函数: tf.nn.relu()```
<img src="/uploads/default/original/1X/351c2cbb108ed89f3e84d66a82e484c80f98a0eb.png" width="311" height="210">

**三、softmax和cross_entopy原理**
softmax: 用于计算概率分布

cross-entrop:用于度量两概率之间的相似性


**四、tf.placeholder()与tf.constan()、tf.Variable()的区别?**

tf.constant(value,dtype=None,shape=None,name=’Const’) 创建一个常量tensor,按照给出value来赋值,可以用shape来指定其形状。value可以是一个数,也可以是一个list。 如果是一个数,那么这个常亮中所有值的按该数来赋值。 如果是list,那么len(value)一定要小于等于shape展开后的长度。赋值时,先将value中的值逐个存入。不够的部分,则全部存入value的最后一个值。
Variable表示变量,与Tensor不同,Variable必须初始化以后才能使用。例如:W = tf.Variable(tf.zeros(shape=[1,2]))
placeholder与Variable较为相似,区别在于placeholder常用来表示输入及输出,而Variable常用来表示中间变量。placeholder至少要求指定变量类型和shape。
摘自:glory558

**五、举例说明:tf.Graph()?**
使用tensorflow训练神经网络包括两部分:构建计算图和运行计算图。

**六、tf.name_scope()和tf.variable_scope()的理解?**
tf.variable_scope可以让变量有相同的命名,包括tf.get_variable得到的变量,还有tf.Variable的变量;tf.name_scope可以让变量有相同的命名,只是限于tf.Variable的变量

#8

写的非常好👍,加油💪


#9

Week 2 实践任务


test1 tenforflow实现Logistic Regression算法

本文以DL的入门基础案例《手写数字识别》来实现LR 算法
talk is cheap, show me the code!

# -*- coding: utf-8 -*-
import tensorflow as tf

# auto download  mnist datasets
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("./MNIST_Data", one_hot=True)
# 下载下来的数据集分为 60000行的mnist.train + 10000行的mnist.test 每张图片是28 * 28的像素点,展开之后 mnist.train.images是一个形状为[60000, 784]的张量

# 我们想使用softmax得到给定图片代表每个数字的概率
# first step : 对图片像素进行加权求和  wx + b
# second step: 转换为概率: y = softmax(wx + b)

# Now, let's begin!
# 为了实现高效的数值计算,tf做的处理是 不单独运行单一的复杂计算,而是先用图秒速一系列可交互的计算操作,然后全部一起在python外执行。

# 我们通过操作符号变量来描述这些可交互的操作单元,可以用以下方式创建
x = tf.placeholder("float", [None, 784])#x 不是一个特定的值,而是一个占位符 placeholder

#init weight & bias
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

# softmax model
y = tf.nn.softmax(tf.matmul(x,W) + b) # y = softmax(wx + b)

# 训练模型
# 训练模型之前,我们想要使用一个loss function来评估我们的模型是好是坏,我们使用交叉熵

y_ = tf.placeholder("float", [None, 10])
cross_entropy = -tf.reduce_sum(y_ * tf.log(y)) #用 tf.reduce_sum 计算张量的所有元素的总和

#接下来我们只需要调用tf中描述各单元的图即可对模型进行训练
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#在运行计算之前,我们需要添加一个操作来初始化我们创建的变量
init = tf.initialize_all_variables()

# 在session中启动我们的model
sess = tf.Session()
sess.run(init)

for i in range(1500):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

#评估我们的模型,tf.equal(x1, x2)来表示x1 与 x2的值是否相等
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))

#把bool值转换为浮点数 并对结果取平均
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

#result
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

RESULT:


#10

NN 手写识别

import tensorflow as tf 
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('./MNIST_data', one_hot=True)

sess = tf.InteractiveSession()

x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape = [None, 10])

W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

sess.run(tf.initialize_all_variables())

y = tf.nn.softmax(tf.matmul(x, W) + b)
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

for i in range(1000):
    batch = mnist.train.next_batch(50)
    train_step.run(feed_dict={x:batch[0], y_:batch[1]})
    
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))  
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels})) 

def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
  
x_image = tf.reshape(x, [-1,28,28,1])  
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)

W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)

W_fc1 = weight_variable([7 * 7 * 64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
W_fc2 = weight_variable([1024, 10])
b_fc2 = bias_variable([10])
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)

cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
sess.run(tf.initialize_all_variables())
for i in range(6000):
    batch = mnist.train.next_batch(50)
    if i%100 == 0:
        train_accuracy = accuracy.eval(feed_dict={x:batch[0], y_: batch[1], keep_prob: 1.0})
        print("step %d, training accuracy %g"%(i, train_accuracy))
    train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

epoch: 6000: RESULT: 0.989…:cold_sweat: