tersorflow2.1笔记

@tf.function 使用

Reference: https://yaoyaowd.medium.com/tensorflow-2-0%E4%B8%8A%E6%89%8B6-%E8%A7%A3%E5%89%96tf-function%E7%9A%84%E4%BD%BF%E7%94%A8-b48cef249ca4

Tensorflow2.1代码像普通的Python代码一样简单。在Tensorflow 2.0中，会自动的对被@tf.function装饰的函数进行AutoGraph优化．

1
2
3
4
5
a = tf.constant([[10,10],[11.,1.]])
x = tf.constant([[1.,0.],[0.,1.]])
b = tf.Variable(12.)
y = tf.matmul(a, x) + b
print(y.numpy())

代码非常易读，但是也带来了执行效率低的问题，因为代码需要依赖Python的解释器来进行计算，无法对数据流以及计算图进行优化．

为了在代码可读性和代码速度之间保持平衡，Tensorflow 2.0引入了tf.function这一概念．

我们来粗浅的看一下被tf.function装饰的函数第一次执行时都做了什么：

  1. 函数被执行并且被跟踪(tracing)．Eager execution处于关闭状态，所有的Tensorflow函数被当做tf.Operation进行图的创建．
  2. AutoGraph被唤醒，去检测Python代码可以转为Tensorflow的逻辑，比如while > tf.while, for > tf.while, if > tf.cond, assert > tf.assert．
  3. 通过以上两部，我们对函数进行建图，为了保证Python代码中每一行的执行顺序，tf.control_dependencies被自动加入到代码中．保证第i行执行完后我们会执行第i+1行．
  4. 返回tf.Graph，根据函数名和输入参数，我们将这个graph存到一个cache中．
  5. 对于任何一个该函数的调用，我们会重复利用cache中的计算图进行计算．

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def f():
    a = tf.constant([[10,10],[11.,1.]])
    x = tf.constant([[1.,0.],[0.,1.]])
    b = tf.Variable(12.)
    y = tf.matmul(a, x) + b
    return y
print(f().numpy())
#执行结果
[[22. 22.]
 [23. 13.]]
@tf.function
def f():
    a = tf.constant([[10,10],[11.,1.]])
    x = tf.constant([[1.,0.],[0.,1.]])
    b = tf.Variable(12.)
    y = tf.matmul(a, x) + b
    print("PRINT: ", y)
    tf.print("TF-PRINT: ", y)
    return y
f()
#执行结果
PRINT:  Tensor("add:0", shape=(2, 2), dtype=float32)
ValueError: tf.function-decorated function tried to create variables on non-first call.

咦，为什么代码报错了？

tf.function可能会对一段Python函数进行多次执行来构图，在多次执行的过程中，同样的Variable被创建了多次，产生错误．

这其实也是一个很容易混乱的概念，在eager mode下一个Variable是一个Python object，所以会在执行范围外被销毁．但是在tf.function的装饰下，Variable变成了tf.Variable，是在Graph中持续存在的．

把一个在eager mode下正常执行的函数转换到Tensorflow图形式，需要一边思考着计算图一边构建程序．

解决方案：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 将所有的内容写到一个class里，就好像Keras layer一样,所有的Variable都是class的内部参数(self._b)，将class的__call__()通过tf.function装饰．
class F():
    def __init__(self):
        self._b = None
    @tf.function
    def __call__(self):
        a = tf.constant([[10, 10], [11., 1.]])
        x = tf.constant([[1., 0.], [0., 1.]])
        if self._b is None:
            self._b = tf.Variable(12.)
        y = tf.matmul(a, x) + self._b
        print("PRINT: ", y)
        tf.print("TF-PRINT: ", y)
        return y
f = F()
f()
1
2
3
4
5
6
7
8
9
10
11
# 外部变量传入的形式
@tf.function
def f(b):
    a = tf.constant([[10,10],[11.,1.]])
    x = tf.constant([[1.,0.],[0.,1.]])
    y = tf.matmul(a, x) + b
    print("PRINT: ", y)
    tf.print("TF-PRINT: ", y)
    return y
b = tf.Variable(12.)
f(b)

Tf.keras.Metrics

Reference: https://blog.csdn.net/qq_39507748/article/details/105267168

  • reset_states(),清除之前的计算结果，相当于复位重新开始计算
  • result()，计算并且返回结果
  • update_state()，将每一次更新的数据作为一组数据，这样在真正计算的时候会计算出每一组的结果，然后求多组结果的平均值。但并不会直接计算，计算还是在调用 result()时完成

1、tf.keras.metrics.Accuracy

1
2
3
4
5
6
7
8
9
10
11
12
13
m = tf.keras.metrics.Accuracy() 
_ = m.update_state([1, 2, 3, 4], [0, 2, 3, 4]) 
m.result().numpy() 
#输出：0.75
m.reset_states() 
'''
通俗来讲，sample_weight的作用就是用来指定
哪些数据用来计算结果，哪些不参与计算
'''
_ = m.update_state([1, 2, 3, 4], [0, 2, 3, 4], 
                    sample_weight=[1, 1, 0, 0]) 
m.result().numpy() 
#输出：0.5

2、tf.keras.metrics.BinaryAccuracy

1
2
3
4
5
6
7
8
9
10
'''
threshold用来指定一个阈值，如果数值超过这个阈值就认为是1，否则就是0
'''
tf.keras.metrics.BinaryAccuracy(
    name='binary_accuracy', dtype=None, threshold=0.5
)
m = tf.keras.metrics.BinaryAccuracy()
m.update_state([1, 1, 0, 0], [0.98, 1, 0, 0.6])
print('Final result: ', m.result().numpy())  # Final result: 0.75

3、tf.keras.metrics.BinaryCrossentropy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
tf.keras.metrics.BinaryCrossentropy(
    name='binary_crossentropy', dtype=None, from_logits=False, label_smoothing=0
)
m = tf.keras.metrics.BinaryCrossentropy()
m.update_state([1., 0., 1., 0.], [1., 1., 1., 0.])
'''
# EPSILON = 1e-7, y = y_true, y` = y_pred, Y_MAX = 0.9999999
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [Y_MAX, Y_MAX, Y_MAX, EPSILON]
# Metric = -(y log(y` + EPSILON) + (1 - y) log(1 - y` + EPSILON))
#        = [-log(Y_MAX + EPSILON), -log(1 - Y_MAX + EPSILON),
#           -log(Y_MAX + EPSILON), -log(1)]
#        = [(0 + 15.33) / 2, (0 + 0) / 2]
# Reduced metric = 7.665 / 2
'''
print('Final result: ', m.result().numpy())  # Final result: 3.833

4、tf.keras.metrics.CategoricalAccuracy

1
2
3
4
5
m = tf.keras.metrics.CategoricalAccuracy() 
_ = m.update_state([[0, 0, 1], [0, 1, 0]], [[0.1, 0.9, 0.8], 
                    [0.05, 0.95, 0]]) 
m.result().numpy() 
#输出：0.5

5、tf.keras.metrics.CategoricalCrossentropy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
'''
from_logits:为True时，表示预测结果非概率分布，而是确切的类别值；
            为False时表示输出是概率分布
'''
tf.keras.metrics.CategoricalCrossentropy(
    name='categorical_crossentropy', dtype=None, 
    from_logits=False,label_smoothing=0
)
m = tf.keras.metrics.CategoricalCrossentropy()
m.update_state([[0, 1, 0], [0, 0, 1]],
               [[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
'''
# EPSILON = 1e-7, y = y_true, y` = y_pred
# y` = clip_ops.clip_by_value(output, EPSILON, 1. - EPSILON)
# y` = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# xent = -sum(y * log(y'), axis = -1)
#      = -((log 0.95), (log 0.1))
#      = [0.051, 2.302]
# Reduced xent = (0.051 + 2.302) / 2
'''
print('Final result: ', m.result().numpy())  # Final result: 1.176

6、tf.keras.metrics.SparseCategoricalAccuracy

1
2
3
4
m = tf.keras.metrics.SparseCategoricalAccuracy() 
_ = m.update_state([[2], [1]], [[0.1, 0.9, 0.8], [0.05, 0.95, 0]]) 
m.result().numpy() 
#输出：0.5

7、tf.keras.metrics.SparseCategoricalCrossentropy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
m = tf.keras.metrics.SparseCategoricalCrossentropy()
m.update_state(
  [1, 2],
  [[0.05, 0.95, 0], [0.1, 0.8, 0.1]])
'''
# y_true = one_hot(y_true) = [[0, 1, 0], [0, 0, 1]]
# logits = log(y_pred)
# softmax = exp(logits) / sum(exp(logits), axis=-1)
# softmax = [[0.05, 0.95, EPSILON], [0.1, 0.8, 0.1]]
# xent = -sum(y * log(softmax), 1)
# log(softmax) = [[-2.9957, -0.0513, -16.1181], [-2.3026, -0.2231, -2.3026]]
# y_true * log(softmax) = [[0, -0.0513, 0], [0, 0, -2.3026]]
# xent = [0.0513, 2.3026]
# Reduced xent = (0.0513 + 2.3026) / 2
'''
print('Final result: ', m.result().numpy())  # Final result: 1.176

数据预处理形式

图片数据建模示例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import tensorflow as tf 
from tensorflow.keras import datasets,layers,models
BATCH_SIZE = 100
# 图片预处理
def load_image(img_path,size = (32,32)):
    label = tf.constant(1,tf.int8) if tf.strings.regex_full_match(img_path,".*automobile.*") \
            else tf.constant(0,tf.int8)
    img = tf.io.read_file(img_path)
    img = tf.image.decode_jpeg(img) #注意此处为jpeg格式
    img = tf.image.resize(img,size)/255.0
    return(img,label)
#使用并行化预处理num_parallel_calls 和预存数据prefetch来提升性能
# 遍历文件夹， 对图片数据做预处理， shuffle， 预存数据
ds_train = tf.data.Dataset.list_files("../../data/cifar2/train/*/*.jpg") \
           .map(load_image, num_parallel_calls=tf.data.experimental.AUTOTUNE) \
           .shuffle(buffer_size = 1000).batch(BATCH_SIZE) \
           .prefetch(tf.data.experimental.AUTOTUNE)  
ds_test = tf.data.Dataset.list_files("../../data/cifar2/test/*/*.jpg") \
           .map(load_image, num_parallel_calls=tf.data.experimental.AUTOTUNE) \
           .batch(BATCH_SIZE) \
           .prefetch(tf.data.experimental.AUTOTUNE)  
# 迭代器取一张
# 可以使用ds_train.take(1)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# ------------------
# Keras保存模型结构及权重
# ------------------
model.save('data/keras_model.h5')  
del model  #删除现有模型
# identical to the previous one
model = models.load_model('data/keras_model.h5')
json_str = model.to_json()
model_json = models.model_from_json(json_str)
print(json_str)
print(model_json)
# ------------------
# tensorflow保存权重
# ------------------
model.save_weights('../../data/tf_model_weights.ckpt',save_format = "tf")
# 保存模型结构与模型参数到文件,该方式保存的模型具有跨平台性便于部署
model.save('../../data/tf_model_savedmodel', save_format="tf")
print('export saved model.')
model_loaded = tf.keras.models.load_model('../../data/tf_model_savedmodel')
# model_loaded.evaluate(x_test,y_test)
文本数据预处理方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
# 1. tf.keras.preprocessing中的Tokenizer词典构建工具和tf.keras.utils.Sequence构建文本数据生成器管道
# https://zhuanlan.zhihu.com/p/67697840
# 2. tf.data.Dataset 和 keras.layers.experimental.preprocessing.TextVectorization预处理
MAX_WORDS = 10000  # 仅考虑最高频的10000个词
MAX_LEN = 200  # 每个样本保留200个词的长度
BATCH_SIZE = 20 
def split_line(line):
    arr = tf.strings.split(line, "\t")
    label = tf.expand_dims(tf.cast(tf.strings.to_number(arr[0]), tf.int32), axis=0)
    text = tf.expand_dims(arr[1], axis=0)
    return text, label
# 处理文件夹，并行处理
ds_train_raw =  tf.data.TextLineDataset(filenames = [train_data_path]) \
   .map(split_line,num_parallel_calls = tf.data.experimental.AUTOTUNE) \
   .shuffle(buffer_size = 1000).batch(BATCH_SIZE) \
   .prefetch(tf.data.experimental.AUTOTUNE)
ds_test_raw = tf.data.TextLineDataset(filenames = [test_data_path]) \
   .map(split_line,num_parallel_calls = tf.data.experimental.AUTOTUNE) \
   .batch(BATCH_SIZE) \
   .prefetch(tf.data.experimental.AUTOTUNE)
def clean_text(text):
    lowercase = tf.strings.lower(text)
    stripped_html = tf.strings.regex_replace(lowercase, '<br />', ' ')
    cleaned_punctuation = tf.strings.regex_replace(stripped_html,
         '[%s]' % re.escape(string.punctuation),'')
    return cleaned_punctuation
vectorize_layer = TextVectorization(
    standardize=clean_text,
    split = 'whitespace',
    max_tokens=MAX_WORDS-1, #有一个留给占位符
    output_mode='int',
    output_sequence_length=MAX_LEN)
ds_text = ds_train_raw.map(lambda text,label: text)
vectorize_layer.adapt(ds_text)
print(vectorize_layer.get_vocabulary()[0:100])
#单词编码
ds_train = ds_train_raw.map(lambda text,label:(vectorize_layer(text),label)) \
     .prefetch(tf.data.experimental.AUTOTUNE)
ds_test = ds_test_raw.map(lambda text,label:(vectorize_layer(text),label)) \
     .prefetch(tf.data.experimental.AUTOTUNE)
时序数据预处理方式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
df = pd.DataFrame()
df['confirmed_num'] = [15, 12, 13]
df['cured_num'] = [13, 12, 12]
df['dead_num'] = [10, 123, 134]
df['date'] = ['2020-01-02', '2020-02-02', '2020-03-02']
df = df.set_index("date")
print(df)
# 做差分处理
dfdiff = df.diff(periods=1).dropna()
dfdiff = dfdiff.reset_index("date")
print(dfdiff)
"""
confirmed_num  cured_num  dead_num
date                                          
2020-01-02             15         13        10
2020-02-02             12         12       123
2020-03-02             13         12       134
         date  confirmed_num  cured_num  dead_num
0  2020-02-02           -3.0       -1.0     113.0
1  2020-03-02            1.0        0.0      11.0
"""
#用某日前3天窗口数据作为输入预测该日数据
WINDOW_SIZE = 3
def batch_dataset(dataset):
    dataset_batched = dataset.batch(WINDOW_SIZE,drop_remainder=True)
    return dataset_batched
# 取window_size个数据，然后shift
ds_data = tf.data.Dataset.from_tensor_slices(tf.constant(dfdiff.values,dtype = tf.float32)) \
   .window(WINDOW_SIZE,shift=1).flat_map(batch_dataset)
print(list(ds_data.as_numpy_iterator()))
ds_label = tf.data.Dataset.from_tensor_slices(
    tf.constant(dfdiff.values[WINDOW_SIZE:],dtype = tf.float32))
print(list(ds_label.as_numpy_iterator()))
#数据较小，可以将全部训练数据放入到一个batch中，提升性能
ds_train = tf.data.Dataset.zip((ds_data,ds_label)).batch(2).cache()

Jupiter 查看文档； 导出代码成py

赏

谢谢你请我吃糖果

支付宝
微信

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

怕人询问，咽泪装欢