DLND-Week3

[chenghong-lin-nu]

Intro to Tensorflow

• 在tensorflow中，数据是被封装在一个Object叫tensor。

Session

• TensorFlow’s api是构建基于Computational Graph（计算图）上的。
• TensorFlow Session is an environment for running a graph.

  
  import tensorflow as tf

Create TensorFlow object called hello_constant

hello_constant = tf.constant('Hello World!')

with tf.Session() as sess:

Run the tf.constant operation in the session

output = sess.run(hello_constant)
print(output)

### Feeding data into Tensorflow
#### tf.placeholder() & feed_dict
- 要使用这个的原因是因为TensorFlow model to take in different datasets with different parameters.
![image](https://user-images.githubusercontent.com/16880879/36352015-2216575c-14ed-11e8-97d2-e509f126f743.png)

### TensorFlow Math
- Addition: It takes in two numbers, two tensors, or one of each, and returns their sum as a tensor.
```python
x = tf.add(5, 2)  # 7

• Subtraction & Multiplication

  x = tf.subtract(10, 4) # 6
  y = tf.multiply(2, 5)  # 10

• Converting types(转变类型)

  tf.subtract(tf.cast(tf.constant(2.0), tf.int32), tf.constant(1))   # 1

[chenghong-lin-nu]

Classification

Supervised Classification

Logistic Classifier(又叫做Linear Classifier)

• 它接收一个Input，然后apply linear function去生成预测。
• 那么我们怎样根据生成的预测值去判断分类呢？
• 首先我们将每个生成的值转化为概率。
• 因为每个图片有且仅有一个正确的label，所以我们想让正确的接近1，错误的接近0。转化通过使用softmax函数。

tf.Variable()

x = tf.Variable(5)

• The tf.Variable class creates a tensor with an initial value that can be modified, much like a normal Python variable.
• 该 tensor 把它的状态存在 session 里，所以你必须手动初始化它的状态。
• 你将使用 tf.global_variables_initializer() 函数来初始化所有可变 tensor。
• The tf.global_variables_initializer() call returns an operation that will initialize all TensorFlow variables from the graph.

  init = tf.global_variables_initializer()
  with tf.Session() as sess:
  sess.run(init)

tf.truncated_normal()

• tf.truncated_normal() function to generate random numbers from a normal distribution.

  n_features = 120
  n_labels = 5
  weights = tf.Variable(tf.truncated_normal((n_features, n_labels)))

tf.zeros()

n_labels = 5
bias = tf.Variable(tf.zeros(n_labels)) # [ 0.  0.  0.  0.  0.]

[chenghong-lin-nu]

Activation Functions

ReLU and Softmax Activation Functions

Rectified Linear Units

• f(x)=max(x,0)

Softmax

• Softmax把每个节点的输出压缩成0-1.
• It also divides each output such that the total sum of the outputs is equal to 1
• You would use a sigmoid with one output unit for binary classification.
• 但是当有多个output unit的时候，那么使用Softmax函数会好一点。
• Just remember that the outputs are squashed and they sum to one.
• 它是一个网络预测多分类问题的最佳输出激活函数。

TensorFlow Softmax

x = tf.nn.softmax([2.0, 1.0, 0.2])

One hot Encoding

• 因为我们需要用数学方式表示label。每个标签将用一个向量表示。正确标签的编码是1，其他的则是0。这个就叫做独热编码。
• One-Hot 编码，又称一位有效编码，其方法是使用N位状态寄存器来对N个状态进行编码，每个状态都由他独立的寄存器位，并且在任意时候，其中只有一位有效。这里题目要求返回为 one_hot 编码的 Numpy 数组的标签列表，即根据标签值来返回只有1位有效（即只有1位为1，其他位为0）的one_hot 编码。因为标签的可能值为 0 到 9，所以我们这里需要给0到9的标签分别创建编码映射，比如将标签值5映射为：[ 0. 0. 0. 0. 0. 1. 0. 0. 0. 0.]。 使用sklearn的函数时候的时候，lb.fit([0,1,2,3,4,5,6,7,8,9])是创建编码映射，然后z = lb.transform(x)会直接调用创建好的编码映射，建议查看下函数手册进一步理解下。
• scikit-learn 的 LabelBinarizer 函数可以很方便地把你的目标（labels）转化成独热编码向量。

  
  import numpy as np
  from sklearn import preprocessing

Example labels

labels = np.array([1,5,3,2,1,4,2,1,3])

Create the encoder

lb = preprocessing.LabelBinarizer()

Here the encoder finds the classes and assigns one-hot vectors

lb.fit(labels)

And finally, transform the labels into one-hot encoded vectors

lb.transform(labels)

array([[1, 0, 0, 0, 0], [0, 0, 0, 0, 1], [0, 0, 1, 0, 0], [0, 1, 0, 0, 0], [1, 0, 0, 0, 0], [0, 0, 0, 1, 0], [0, 1, 0, 0, 0], [1, 0, 0, 0, 0], [0, 0, 1, 0, 0]])

Categorical Cross-Entropy(分类的交叉熵)

• We want our error to be proportional（成比例的） to how far apart these vectors are. To calculate this distance, we'll use the cross entropy（交叉熵）
• 当训练网络的时候的目标是to make our prediction vectors as close as possible to the label vectors by minimizing the cross entropy.
• 以下是交叉熵的计算公式。

Cross Entropy in TensorFlow

• 你需要用到以下两个函数：tf.reduce_sum()， tf.log()
• The tf.reduce_sum() function takes an array of numbers and sums them together.
• tf.log() takes the natural log of a number.（自然对数，以e为底）

Minimize Cross Entropy

• 下面那个东西叫training loss：
• 这里的S是指softmax函数，D是指交叉熵误差函数。
• 减少loss可以用梯度下降哦~

Measuring Performance

• 有些时候，网络倾向于去记住training data，然后这样它们在training dataset中表现的很好，但是在预测其他的时候就不是那么好了。所以为了解决到底怎样判断它是不是表现的好，见下图。
• 把training dataset中挖出一小部分然后作为test dataset，然后用test data去判断这个网络的效果好不好。
• 但是有可能这些test data在训练的过程中会渗入到training data中去，这样也会使你的网络记住。
• 那么这个时候，你从training data中再取一小部分数据，然后作为test data并且锁住，然后你用validation set作为数据的验证集。

SGD(Stochastic Gradient Descent-随机梯度下降)

• 理解的内容待填。。
• 我们将使用的估计就只是简单的计算随机选取的一小部分训练数据的平均损失。

Momentum & Learning rate decay(动量和学习率衰减)

• 一些内容不太明白，待补。。。

Mini-batching

• Mini-batching是一个技术：training on subsets of the dataset instead of all the data at one time

Lab: Tensorflow Neural Network

• 这个实验也是讲的比较好的，可以指导你在tf里面创建一个单层的神经网络。
• 项目地址
• 在在intro-to-tensorflow 这个文件夹里。

[chenghong-lin-nu]

Deep Neural Networks

TensorFlow ReLUs

• ReLUs是一个非线性激活函数。
• TensorFlow 提供了 ReLU 函数 tf.nn.relu()

  # Hidden Layer with ReLU activation function
  hidden_layer = tf.add(tf.matmul(features, hidden_weights), hidden_biases)
  hidden_layer = tf.nn.relu(hidden_layer)
  output = tf.add(tf.matmul(hidden_layer, output_weights), output_biases)

Deep Neural Network in TensorFlow

• 这里面详细地讲述了编写一个两层神经网络的过程，以及一些参数的了解。
• 待记录。。。。

Training a Deep Learning Network

• 我们可以增加hidden layer的尺寸，但是这并不是一个高效的方法。
• 实际上，我们可以增加更多的层的方式，来使我们的模型变得更深。

Save and Restore TensorFlow Models（保存&恢复tf模型）

• 一般来说，如果我们关掉tf.session的话，那么训练过的东西就都没有了。
• 但是，幸运的是，tf.train.Saver - give you the ability to save your progress.
• This class provides the functionality to save any tf.Variable to your file system.

  Saving Variables

  
  import tensorflow as tf

The file path to save the data

save_file = './model.ckpt'

Two Tensor Variables: weights and bias

weights = tf.Variable(tf.truncated_normal([2, 3])) bias = tf.Variable(tf.truncated_normal([3]))

Class used to save and/or restore Tensor Variables

saver = tf.train.Saver()

with tf.Session() as sess:

Initialize all the Variables

sess.run(tf.global_variables_initializer())

# Show the values of weights and bias
print('Weights:')
print(sess.run(weights))
print('Bias:')
print(sess.run(bias))

# Save the model
saver.save(sess, save_file)

### Loading Variables
```python
# Remove the previous weights and bias
tf.reset_default_graph()

# Two Variables: weights and bias
weights = tf.Variable(tf.truncated_normal([2, 3]))
bias = tf.Variable(tf.truncated_normal([3]))

# Class used to save and/or restore Tensor Variables
saver = tf.train.Saver()

with tf.Session() as sess:
    # Load the weights and bias
    saver.restore(sess, save_file)

    # Show the values of weights and bias
    print('Weight:')
    print(sess.run(weights))
    print('Bias:')
    print(sess.run(bias))

• 以上操作对于model来说也是可以的，只不过一个是写在session里面的。

Name Error

• 如果你不给变量一个name的话，那么tf会自动给它一个名字，但是这样子经常会出现错误，就是万一变量顺序换一下，那么你下次导入进来的时候就会出现问题。
• 所以最好的方式还是给变量进行手动的name属性赋值。

Regularization(正则化)

• 防止过拟合（overfitting）的2个方式是：
• 1.Early Termination: 就是观察我们验证集(validation set)的性能，当它停止提高时，立刻停止训练。
• 2.Regularization（正则化）：指对你的网络进行人为的约束，隐式地减少自由参数的数量。那么用的方法是L2 Regularization，见下图。

L2 Regularization

Dropout（丢弃？）

• Dropout 是一个降低过拟合的正则化技术。它在网络中暂时的丢弃一些单元（神经元），以及与它们的前后相连的所有节点。
• 对于你训练网络的每个样本，随机地将某些的一半设置为0.

TensorFlow Dropout

• tf.nn.dropout()：可以帮助你来实现dropout。

  
  keep_prob = tf.placeholder(tf.float32) # probability to keep units

hidden_layer = tf.add(tf.matmul(features, weights[0]), biases[0]) hidden_layer = tf.nn.relu(hidden_layer) hidden_layer = tf.nn.dropout(hidden_layer, keep_prob)

logits = tf.add(tf.matmul(hidden_layer, weights[1]), biases[1])

- tf.nn.dropout()中有两个参数：
- 1.hidden_layer: the tensor to which you would like **to apply dropout**
- 2.keep_prob: **the probability of keeping (i.e. not dropping) any given unit**
- （keep_prob allows you to adjust the number of units to drop）
- During **training**, a good starting value for keep_prob is 0.5.
- During **testing**, use a keep_prob value of 1.0 to keep all units and maximize the power of the model.