devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【TensorFlow基础】加载和预处理数据_tensorflow 数据预处理

作者：我家自动化 | 2024-03-16 13:24:10

赞

踩

tensorflow 数据预处理

目录

1.图像

1.1 配置环境

1.2 加载数据集

1.3 数据预处理

1.4 训练模型

2.CSV

2.1 配置环境

2.2 加载数据

2.3 数据预处理

2.4 构建模型

2.5 训练、评估和预测

3.Numpy

3.1 配置环境

3.2 加载数据

3.3 数据预处理

4.pandas.DataFrame

4.1 配置环境

4.2 加载数据

4.3 数据预处理

4.4 创建并训练模型

5.TFRecord和tf.Example

6.文本

6.1 配置环境

6.2 加载数据

6.3 数据预处理

6.4 构建模型

6.5 训练模型

1.图像

1.1 配置环境

  1. import tensorflow as tf
  2. AUTOTUNE = tf.data.experimental.AUTOTUNE

1.2 加载数据集

使用tf.data加载图片

  1. # 下载数据集
  2. import pathlib
  3. data_root_orig = tf.keras.utils.get_file(origin='https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
  4.                                          fname='flower_photos', untar=True)
  5. data_root = pathlib.Path(data_root_orig)
  6. print(data_root)
  7.  
  8. '''
  9. Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz
  10. 228813984/228813984 [==============================] - 3s 0us/step
  11. /home/kbuilder/.keras/datasets/flower_photos
  12. '''
  13.  
  14. # 查看数据集
  15. for item in data_root.iterdir():
  16.   print(item)
  17.  
  18. '''
  19. /home/kbuilder/.keras/datasets/flower_photos/daisy
  20. /home/kbuilder/.keras/datasets/flower_photos/dandelion
  21. /home/kbuilder/.keras/datasets/flower_photos/sunflowers
  22. /home/kbuilder/.keras/datasets/flower_photos/roses
  23. /home/kbuilder/.keras/datasets/flower_photos/LICENSE.txt
  24. /home/kbuilder/.keras/datasets/flower_photos/tulips
  25. '''

1.3 数据预处理

  1. # 1. 打乱数据集
  2. import random
  3. all_image_paths = list(data_root.glob('*/*'))
  4. all_image_paths = [str(path) for path in all_image_paths]
  5. random.shuffle(all_image_paths)
  6.  
  7. image_count = len(all_image_paths)
  8. image_count
  9. # 3670
  10.  
  11. # 检查图片
  12. import os
  13. attributions = (data_root/"LICENSE.txt").open(encoding='utf-8').readlines()[4:]
  14. attributions = [line.split(' CC-BY') for line in attributions]
  15. attributions = dict(attributions)
  16.  
  17. import IPython.display as display
  18. def caption_image(image_path):
  19.     image_rel = pathlib.Path(image_path).relative_to(data_root)
  20.     return "Image (CC BY 2.0) " + ' - '.join(attributions[str(image_rel)].split(' - ')[:-1])
  21.  
  22. for n in range(3):
  23.   image_path = random.choice(all_image_paths)
  24.   display.display(display.Image(image_path))
  25.   print(caption_image(image_path))
  26.   print()
  27.  
  28. # 2. 确定每张图片的标签
  29. # 2.1 列出可用的标签
  30. label_names = sorted(item.name for item in data_root.glob('*/') if item.is_dir())
  31. label_names
  32. # ['daisy', 'dandelion', 'roses', 'sunflowers', 'tulips']
  33.  
  34. # 2.2 为每个标签分配索引
  35. label_to_index = dict((name, index) for index, name in enumerate(label_names))
  36. label_to_index
  37. # {'daisy': 0, 'dandelion': 1, 'roses': 2, 'sunflowers': 3, 'tulips': 4}
  38.  
  39. # 2.3 创建一个列表包含每个文件的标签索引
  40. all_image_labels = [label_to_index[pathlib.Path(path).parent.name]
  41.                     for path in all_image_paths]
  42.  
  43. print("First 10 labels indices: ", all_image_labels[:10])
  44. # First 10 labels indices:  [4, 2, 4, 1, 1, 2, 4, 4, 3, 2]
  45.  
  46. # 3. 加载和格式化图片
  47. # 3.1 取第一张图片
  48. img_path = all_image_paths[0]
  49. img_path
  50. # '/home/kbuilder/.keras/datasets/flower_photos/tulips/14099204939_60e6ffa4c3_n.jpg'
  51.  
  52. # 查看原始数据
  53. img_raw = tf.io.read_file(img_path)
  54. print(repr(img_raw)[:100]+"...")
  55. # <tf.Tensor: shape=(), dtype=string, numpy=b'\xff\xd8\xff\xe0\x00\x10JFIF\x00\x01\x01\x00\x00\x01\x00...
  56.  
  57. # 3.2 将原始数据转换为图像tensor
  58. img_tensor = tf.image.decode_image(img_raw)
  59.  
  60. print(img_tensor.shape)
  61. print(img_tensor.dtype)
  62.  
  63. '''
  64. (212, 320, 3)
  65. <dtype: 'uint8'>
  66. '''
  67.  
  68. # 3.3 根据模型调整图像tensor大小
  69. img_final = tf.image.resize(img_tensor, [192, 192])
  70. img_final = img_final/255.0
  71. print(img_final.shape)
  72. print(img_final.numpy().min())
  73. print(img_final.numpy().max())
  74.  
  75. '''
  76. (192, 192, 3)
  77. 0.0
  78. 1.0
  79. '''
  80.  
  81. # 3.4 将以上操作封装在一个函数中
  82. def preprocess_image(image):
  83.   image = tf.image.decode_jpeg(image, channels=3)
  84.   image = tf.image.resize(image, [192, 192])
  85.   image /= 255.0  # normalize to [0,1] range
  86.  
  87.   return image
  88.  
  89. def load_and_preprocess_image(path):
  90.   image = tf.io.read_file(path)
  91.   return preprocess_image(image)
  92.  
  93. # 应用封装好的函数
  94. import matplotlib.pyplot as plt
  95.  
  96. image_path = all_image_paths[0]
  97. label = all_image_labels[0]
  98.  
  99. plt.imshow(load_and_preprocess_image(img_path))
  100. plt.grid(False)
  101. plt.xlabel(caption_image(img_path))
  102. plt.title(label_names[label].title())
  103. print()

构建一个tf.data.Dataset：

使用from_tensor_slices方法可以简单地构建一个tf.data.Dataset

  1. # 1. 构建字符串数据集path_ds
  2. # 将字符串数组切片得到一个字符串数据集path_ds
  3. path_ds = tf.data.Dataset.from_tensor_slices(all_image_paths)
  4.  
  5. print(path_ds)
  6. # <TensorSliceDataset element_spec=TensorSpec(shape=(), dtype=tf.string, name=None)>
  7.  
  8. # 2. 加载并格式化图片，构建图片数据集image_ds
  9. # 创建一个新的图像数据集image_ds，通过在路径数据集上映射 preprocess_image 来动态加载和格式化图片
  10. image_ds = path_ds.map(load_and_preprocess_image, num_parallel_calls=AUTOTUNE)
  11.  
  12. import matplotlib.pyplot as plt
  13.  
  14. plt.figure(figsize=(8,8))
  15. for n, image in enumerate(image_ds.take(4)):
  16.   plt.subplot(2,2,n+1)
  17.   plt.imshow(image)
  18.   plt.grid(False)
  19.   plt.xticks([])
  20.   plt.yticks([])
  21.   plt.xlabel(caption_image(all_image_paths[n]))
  22.   plt.show()
  23.  
  24. # 3. 创建标签数据集label_ds
  25. label_ds = tf.data.Dataset.from_tensor_slices(tf.cast(all_image_labels, tf.int64))
  26.  
  27. for label in label_ds.take(10):
  28.   print(label_names[label.numpy()])
  29.  
  30. # 4. 构建（图片，标签）对数据集image_label_ds
  31. image_label_ds = tf.data.Dataset.zip((image_ds, label_ds))
  32.  
  33. print(image_label_ds)
  34. # <ZipDataset element_spec=(TensorSpec(shape=(192, 192, 3), dtype=tf.float32, name=None), TensorSpec(shape=(), dtype=tf.int64, name=None))>

1.4 训练模型

准备训练数据：

  • 训练数据应被充分打乱；
  • 训练数据应被分割为batch；
  1. # 1. 准备训练数据
  2. BATCH_SIZE = 32
  3.  
  4. # 设置一个和数据集大小一致的 shuffle buffer size（随机缓冲区大小）以保证数据被充分打乱
  5. # 当模型在训练的时候，`prefetch` 使数据集在后台取得 batch，使用额外的内存减少延迟时间。
  6. ds = image_label_ds.shuffle(buffer_size=image_count)  # ds每次输出是不确定的
  7. ds = ds.repeat()                                      # ds每次repeat产生不同的结果
  8. ds = ds.batch(BATCH_SIZE)                             # 将ds分成batch
  9. ds = ds.prefetch(buffer_size=AUTOTUNE)                # 将ds的batch存储好
  10. ds
  11. # <PrefetchDataset element_spec=(TensorSpec(shape=(None, 192, 192, 3), dtype=tf.float32, name=None), TensorSpec(shape=(None,), dtype=tf.int32, name=None))>

1. 顺序很重要：

  • 在 .repeat 之后 .shuffle，会在 epoch 之间打乱数据（当有些数据出现两次的时候，其他数据还没有出现过）；
  • 在 .batch 之后 .shuffle，会打乱 batch 的顺序，但是不会在 batch 之间打乱数据；

2. 在完全打乱中使用较大的缓冲区大小提供更好的随机化但使用更多的内存。
3. 在从随机缓冲区中拉取任何元素前，要先填满它。所以当 Dataset（数据集）启动的时候一个大的 buffer_size（缓冲区大小）可能会引起延迟。
4. 在随机缓冲区完全为空之前，被打乱的数据集不会报告数据集的结尾。Dataset（数据集）由 .repeat 重新启动，导致需要再次等待随机缓冲区被填满。

构建并训练模型：

  1. # 2. 构建模型
  2. # 2.1 使用 MobileNet v2 模型副本进行训练
  3. mobile_net = tf.keras.applications.MobileNetV2(input_shape=(192, 192, 3), include_top=False)
  4.  
  5. # 设置 MobileNet v2 权重不可训练
  6. mobile_net.trainable=False
  7.  
  8. # 将模型输出标准化至 [-1,1] 范围内
  9. def change_range(image,label):
  10.   return 2*image-1, label
  11.  
  12. keras_ds = ds.map(change_range)
  13.  
  14. # MobileNet v2 为每张图片的特征返回一个6*6的空间网格
  15. # 数据集可能需要几秒来启动，因为要填满其随机缓冲区，传递一个batch的图片
  16. image_batch, label_batch = next(iter(keras_ds))
  17.  
  18. feature_map_batch = mobile_net(image_batch)
  19. print(feature_map_batch.shape)
  20. # (32, 6, 6, 1280)
  21. # 每个batch有32条样本，每个样本返回个6*6的空间网格
  22.  
  23. # 2.2 构建模型
  24. model = tf.keras.Sequential([
  25.   mobile_net,
  26.   tf.keras.layers.GlobalAveragePooling2D(),  # 平均空间向量
  27.   tf.keras.layers.Dense(len(label_names), activation = 'softmax')])
  28.  
  29. logit_batch = model(image_batch).numpy()
  30.  
  31. print("min logit:", logit_batch.min())
  32. print("max logit:", logit_batch.max())
  33. print()
  34.  
  35. print("Shape:", logit_batch.shape)
  36.  
  37. '''
  38. min logit: 0.014231807
  39. max logit: 0.7678226
  41. Shape: (32, 5)
  42. '''
  43.  
  44. model.compile(optimizer=tf.keras.optimizers.Adam(),
  45.               loss='sparse_categorical_crossentropy',
  46.               metrics=["accuracy"])
  47.  
  48. # 2.3 查看模型结构
  49. # 此时可训练的变量为dense层中的weight和bias
  50. model.summary()
  51.  
  52. '''
  53. Model: "sequential"
  54. _________________________________________________________________
  55.  Layer (type)                Output Shape              Param #   
  56. =================================================================
  57.  mobilenetv2_1.00_192 (Funct  (None, 6, 6, 1280)       2257984   
  58.  ional)                                                          
  59.                                                                  
  60.  global_average_pooling2d (G  (None, 1280)             0         
  61.  lobalAveragePooling2D)                                          
  62.                                                                  
  63.  dense (Dense)               (None, 5)                 6405      
  64.                                                                  
  65. =================================================================
  66. Total params: 2,264,389
  67. Trainable params: 6,405
  68. Non-trainable params: 2,257,984
  69. _________________________________________________________________
  70. '''
  71.  
  72. # 2.4 训练模型
  73. # 出于演示目的每一个 epoch 只运行 3 step，在传递给 model.fit() 之前指定 step 的数量
  74. steps_per_epoch=tf.math.ceil(len(all_image_paths)/BATCH_SIZE).numpy()
  75. steps_per_epoch
  76. # 115.0
  77.  
  78. model.fit(ds, epochs=1, steps_per_epoch=3)

2.CSV

使用泰坦尼克号乘客的数据，模型会根据乘客的年龄、性别、票务舱和是否独自旅行等特征来预测乘客生还的可能性。

2.1 配置环境

  1. import functools
  2.  
  3. import numpy as np
  4. import tensorflow as tf
  5. import tensorflow_datasets as tfds
  6.  
  7. TRAIN_DATA_URL = "https://storage.googleapis.com/tf-datasets/titanic/train.csv"
  8. TEST_DATA_URL = "https://storage.googleapis.com/tf-datasets/titanic/eval.csv"
  9.  
  10. train_file_path = tf.keras.utils.get_file("train.csv", TRAIN_DATA_URL)
  11. test_file_path = tf.keras.utils.get_file("eval.csv", TEST_DATA_URL)
  12.  
  13. # 让 numpy 数据更易读
  14. np.set_printoptions(precision=3, suppress=True)

2.2 加载数据

查看csv文件了解文件格式：

  1. head {train_file_path}
  2.  
  3. '''
  4. survived,sex,age,n_siblings_spouses,parch,fare,class,deck,embark_town,alone
  5. 0,male,22.0,1,0,7.25,Third,unknown,Southampton,n
  6. 1,female,38.0,1,0,71.2833,First,C,Cherbourg,n
  7. 1,female,26.0,0,0,7.925,Third,unknown,Southampton,y
  8. 1,female,35.0,1,0,53.1,First,C,Southampton,n
  9. 0,male,28.0,0,0,8.4583,Third,unknown,Queenstown,y
  10. 0,male,2.0,3,1,21.075,Third,unknown,Southampton,n
  11. 1,female,27.0,0,2,11.1333,Third,unknown,Southampton,n
  12. 1,female,14.0,1,0,30.0708,Second,unknown,Cherbourg,n
  13. 1,female,4.0,1,1,16.7,Third,G,Southampton,n
  14. '''

CSV 文件的每列都会有一个列名，dataset 的构造函数会自动识别这些列名。如果文件的第一行不包含列名，那么需要将列名通过字符串列表传给 make_csv_dataset 函数的 column_names 参数。

  1. CSV_COLUMNS = ['survived', 'sex', 'age', 'n_siblings_spouses', 'parch', 'fare', 'class', 'deck', 'embark_town', 'alone']
  2.  
  3. dataset = tf.data.experimental.make_csv_dataset(
  4.      ...,
  5.      column_names=CSV_COLUMNS,
  6.      ...)

这个示例使用了所有的列。如果你需要忽略数据集中的某些列，创建一个包含你需要使用的列的列表，然后传给构造器的（可选）参数 select_columns。

  1. dataset = tf.data.experimental.make_csv_dataset(
  2.   ...,
  3.   select_columns = columns_to_use, 
  4.   ...)

指定标签所在的列：

  1. LABEL_COLUMN = 'survived'
  2. LABELS = [0, 1]

读取CSV数据并创建dataset：

  1. def get_dataset(file_path):
  2.   dataset = tf.data.experimental.make_csv_dataset(
  3.       file_path,
  4.       batch_size=12, # 为了示例更容易展示，手动设置较小的值
  5.       label_name=LABEL_COLUMN,
  6.       na_value="?",
  7.       num_epochs=1,
  8.       ignore_errors=True)
  9.   return dataset
  10.  
  11. raw_train_data = get_dataset(train_file_path)
  12. raw_test_data = get_dataset(test_file_path)

dataset 中的每个条目都是一个批次，用一个元组（多个样本，多个标签）表示。样本中的数据组织形式是以列为主的张量（而不是以行为主的张量），每条数据中包含的元素个数就是批次大小（这个示例中是 12）。

  1. examples, labels = next(iter(raw_train_data)) # 第一个批次
  2. print("EXAMPLES: \n", examples, "\n")
  3. print("LABELS: \n", labels)
  4.  
  5. '''
  6. EXAMPLES: 
  7.  OrderedDict([('sex', <tf.Tensor: shape=(12,), dtype=string, numpy=
  8. array([b'female', b'female', b'male', b'male', b'female', b'male',
  9.        b'female', b'male', b'female', b'male', b'female', b'male'],
  10.       dtype=object)>), ('age', <tf.Tensor: shape=(12,), dtype=float32, numpy=
  11. array([28., 41., 28., 24., 63., 28., 28., 65., 34.,  9., 27., 30.],
  12.       dtype=float32)>), ...]) 
  14. LABELS: 
  15.  tf.Tensor([1 0 0 0 1 0 0 0 1 0 1 0], shape=(12,), dtype=int32)
  16. '''

2.3 数据预处理

离散数据：对于有些分类的特征（即有些列只能在有限的集合中取值），使用 tf.feature_column API 创建一个 tf.feature_column.indicator_column 集合，每个tf.feature_column.indicator_column 对应一个分类的列。

  1. CATEGORIES = {
  2.     'sex': ['male', 'female'],
  3.     'class' : ['First', 'Second', 'Third'],
  4.     'deck' : ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'],
  5.     'embark_town' : ['Cherbourg', 'Southhampton', 'Queenstown'],
  6.     'alone' : ['y', 'n']
  7. }
  8.  
  9. categorical_columns = []
  10. for feature, vocab in CATEGORIES.items():
  11.   cat_col = tf.feature_column.categorical_column_with_vocabulary_list(
  12.         key=feature, vocabulary_list=vocab)
  13.   categorical_columns.append(tf.feature_column.indicator_column(cat_col))
  14.  
  15. # 查看刚才创建的内容
  16. categorical_columns
  17.  
  18. '''
  19. [IndicatorColumn(categorical_column=VocabularyListCategoricalColumn(key='sex', vocabulary_list=('male', 'female'), dtype=tf.string, default_value=-1, num_oov_buckets=0)),
  20.  IndicatorColumn(categorical_column=VocabularyListCategoricalColumn(key='class', vocabulary_list=('First', 'Second', 'Third'), dtype=tf.string, default_value=-1, num_oov_buckets=0)),
  21.  IndicatorColumn(categorical_column=VocabularyListCategoricalColumn(key='deck', vocabulary_list=('A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'), dtype=tf.string, default_value=-1, num_oov_buckets=0)),
  22.  IndicatorColumn(categorical_column=VocabularyListCategoricalColumn(key='embark_town', vocabulary_list=('Cherbourg', 'Southhampton', 'Queenstown'), dtype=tf.string, default_value=-1, num_oov_buckets=0)),
  23.  IndicatorColumn(categorical_column=VocabularyListCategoricalColumn(key='alone', vocabulary_list=('y', 'n'), dtype=tf.string, default_value=-1, num_oov_buckets=0))]
  24. '''

 连续数据：需要对离散数据进行标准化

  1. def process_continuous_data(mean, data):
  2.   # 标准化数据
  3.   data = tf.cast(data, tf.float32) * 1/(2*mean)
  4.   return tf.reshape(data, [-1, 1])
  5.  
  6. MEANS = {
  7.     'age' : 29.631308,
  8.     'n_siblings_spouses' : 0.545455,
  9.     'parch' : 0.379585,
  10.     'fare' : 34.385399
  11. }
  12.  
  13. numerical_columns = []
  14.  
  15. for feature in MEANS.keys():
  16.   num_col = tf.feature_column.numeric_column(feature, normalizer_fn=functools.partial(process_continuous_data, MEANS[feature]))
  17.   numerical_columns.append(num_col)
  18.  
  19. # 查看创建的内容
  20. numerical_columns
  21.  
  22. '''
  23. [NumericColumn(key='age', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=functools.partial(<function process_continuous_data at 0x7f74fc4f8c10>, 29.631308)),
  24.  NumericColumn(key='n_siblings_spouses', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=functools.partial(<function process_continuous_data at 0x7f74fc4f8c10>, 0.545455)),
  25.  NumericColumn(key='parch', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=functools.partial(<function process_continuous_data at 0x7f74fc4f8c10>, 0.379585)),
  26.  NumericColumn(key='fare', shape=(1,), default_value=None, dtype=tf.float32, normalizer_fn=functools.partial(<function process_continuous_data at 0x7f74fc4f8c10>, 34.385399))]
  27. '''

将离散数据和连续数据的集合合并在一起，并传递给tf.keras.layers.DenseFeatures创建一个进行预处理的输入层。

preprocessing_layer = tf.keras.layers.DenseFeatures(categorical_columns+numerical_columns)

2.4 构建模型

  1. model = tf.keras.Sequential([
  2.   preprocessing_layer,                             # 预处理层
  3.   tf.keras.layers.Dense(128, activation='relu'),   # 全连接层
  4.   tf.keras.layers.Dense(128, activation='relu'),   # 全连接层
  5.   tf.keras.layers.Dense(1, activation='sigmoid'),  # 输出层
  6. ])
  7.  
  8. model.compile(
  9.     loss='binary_crossentropy',
  10.     optimizer='adam',
  11.     metrics=['accuracy'])

2.5 训练、评估和预测

  1. # 1. 训练模型
  2. train_data = raw_train_data.shuffle(500)
  3. test_data = raw_test_data
  4.  
  5. model.fit(train_data, epochs=20)
  6.  
  7. # 2. 评估模型
  8. test_loss, test_accuracy = model.evaluate(test_data)
  9.  
  10. print('\n\nTest Loss {}, Test Accuracy {}'.format(test_loss, test_accuracy))
  11. # Test Loss 0.4481576979160309, Test Accuracy 0.8030303120613098
  12.  
  13. # 3. 进行预测
  14. predictions = model.predict(test_data)
  15.  
  16. # 显示前十个batch结果
  17. for prediction, survived in zip(predictions[:10], list(test_data)[0][1][:10]):
  18.   print("Predicted survival: {:.2%}".format(prediction[0]),
  19.         " | Actual outcome: ",
  20.         ("SURVIVED" if bool(survived) else "DIED"))
  21.  
  22. '''
  23. 22/22 [==============================] - 0s 4ms/step
  24. Predicted survival: 90.08%  | Actual outcome:  SURVIVED
  25. Predicted survival: 0.97%  | Actual outcome:  SURVIVED
  26. Predicted survival: 0.98%  | Actual outcome:  DIED
  27. Predicted survival: 10.06%  | Actual outcome:  SURVIVED
  28. Predicted survival: 62.49%  | Actual outcome:  DIED
  29. Predicted survival: 62.38%  | Actual outcome:  SURVIVED
  30. Predicted survival: 11.18%  | Actual outcome:  SURVIVED
  31. Predicted survival: 60.31%  | Actual outcome:  SURVIVED
  32. Predicted survival: 9.72%  | Actual outcome:  DIED
  33. Predicted survival: 21.93%  | Actual outcome:  DIED
  34. '''

3.Numpy

3.1 配置环境

  1. import numpy as np
  2. import tensorflow as tf

3.2 加载数据

  1. # 从.npz文件中加载数据
  2. DATA_URL = 'https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz'
  3.  
  4. path = tf.keras.utils.get_file('mnist.npz', DATA_URL)
  5. with np.load(path) as data:
  6.   train_examples = data['x_train']
  7.   train_labels = data['y_train']
  8.   test_examples = data['x_test']
  9.   test_labels = data['y_test']
  10.  
  11. # 创建数据集
  12. train_dataset = tf.data.Dataset.from_tensor_slices((train_examples, train_labels))
  13. test_dataset = tf.data.Dataset.from_tensor_slices((test_examples, test_labels))

3.3 数据预处理

  1. # shuffle and batch
  2. BATCH_SIZE = 64
  3. SHUFFLE_BUFFER_SIZE = 100
  4.  
  5. train_dataset = train_dataset.shuffle(SHUFFLE_BUFFER_SIZE).batch(BATCH_SIZE)
  6. test_dataset = test_dataset.batch(BATCH_SIZE)
  7.  
  8.  
  9. # 构建并训练模型
  10. model = tf.keras.Sequential([
  11.     tf.keras.layers.Flatten(input_shape=(28, 28)),
  12.     tf.keras.layers.Dense(128, activation='relu'),
  13.     tf.keras.layers.Dense(10)
  14. ])
  15.  
  16. model.compile(optimizer=tf.keras.optimizers.RMSprop(),
  17.               loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
  18.               metrics=['sparse_categorical_accuracy'])
  19.  
  20. model.fit(train_dataset, epochs=10)

4.pandas.DataFrame

使用由克利夫兰诊所心脏病基金会（Cleveland Clinic Foundation for Heart Disease）提供的小型数据集，此数据集中有几百行CSV。每行表示一个患者，每列表示一个属性（describe）。我们将使用这些信息来预测患者是否患有心脏病，这是一个二分类问题。

4.1 配置环境

  1. !pip install tensorflow-gpu==2.0.0-rc1
  2. import pandas as pd
  3. import tensorflow as tf

4.2 加载数据

  1. # 下载数据集CSV文件
  2. csv_file = tf.keras.utils.get_file('heart.csv', 'https://storage.googleapis.com/applied-dl/heart.csv')
  3.  
  4. # 使用pandas读取CSV文件
  5. df = pd.read_csv(csv_file)
  6.  
  7. # 使用df.head()查看数据集，df.dtypes查看每列特征的数据格式

4.3 数据预处理

  1. # 将分类的特征转换成离散数值
  2. df['thal'] = pd.Categorical(df['thal'])
  3. df['thal'] = df.thal.cat.codes
  4.  
  5. # 使用tf.data.Dataset.from_tensor_slices读取数据
  6. target = df.pop('target')  # label列
  7. dataset = tf.data.Dataset.from_tensor_slices((df.values, target.values))
  8.  
  9. # shuffle and batch
  10. train_dataset = dataset.shuffle(len(df)).batch(1)

4.4 创建并训练模型

  1. def get_compiled_model():
  2.   model = tf.keras.Sequential([
  3.     tf.keras.layers.Dense(10, activation='relu'),
  4.     tf.keras.layers.Dense(10, activation='relu'),
  5.     tf.keras.layers.Dense(1, activation='sigmoid')
  6.   ])
  7.  
  8.   model.compile(optimizer='adam',
  9.                 loss='binary_crossentropy',
  10.                 metrics=['accuracy'])
  11.   return model
  12.  
  13. model = get_compiled_model()
  14. model.fit(train_dataset, epochs=15)

5.TFRecord和tf.Example

先跳过

6.文本

使用tf.data.TextLineDataset加载文本文件，通常被用来以文本文件构建数据集（原文件中的一行为一个样本) 。使用相同作品（荷马的伊利亚特）三个不同版本的英文翻译，然后训练一个模型来通过单行文本确定译者。

6.1 配置环境

  1. import tensorflow as tf
  2.  
  3. import tensorflow_datasets as tfds
  4. import os

6.2 加载数据

  1. DIRECTORY_URL = 'https://storage.googleapis.com/download.tensorflow.org/data/illiad/'
  2. FILE_NAMES = ['cowper.txt', 'derby.txt', 'butler.txt']
  3.  
  4. for name in FILE_NAMES:
  5.   text_dir = tf.keras.utils.get_file(name, origin=DIRECTORY_URL+name)
  6.  
  7. parent_dir = os.path.dirname(text_dir)
  8.  
  9. parent_dir
  10. # '/home/kbuilder/.keras/datasets'

6.3 数据预处理

每个样本都需要单独标记，使用 tf.data.Dataset.map 来为每个样本设定标签。这将迭代数据集中的每一个样本并且返回（ example, label ）对。

  1. def labeler(example, index):
  2.   return example, tf.cast(index, tf.int64)  
  3.  
  4. labeled_data_sets = []
  5.  
  6. for i, file_name in enumerate(FILE_NAMES):
  7.   lines_dataset = tf.data.TextLineDataset(os.path.join(parent_dir, file_name))
  8.   labeled_dataset = lines_dataset.map(lambda ex: labeler(ex, i))
  9.   labeled_data_sets.append(labeled_dataset)

构建数据集：

  1. BUFFER_SIZE = 50000
  2. BATCH_SIZE = 64
  3. TAKE_SIZE = 5000
  4.  
  5. all_labeled_data = labeled_data_sets[0]
  6. for labeled_dataset in labeled_data_sets[1:]:
  7.   all_labeled_data = all_labeled_data.concatenate(labeled_dataset)
  8.  
  9. all_labeled_data = all_labeled_data.shuffle(
  10.     BUFFER_SIZE, reshuffle_each_iteration=False)
  11.  
  12. # 使用 tf.data.Dataset.take 与 print 来查看 (example, label) 对的外观
  13. # numpy 属性显示每个 Tensor 的值
  14. for ex in all_labeled_data.take(5):
  15.   print(ex)
  16.  
  17. '''
  18. (<tf.Tensor: shape=(), dtype=string, numpy=b'To Ida; in his presence once arrived,'>, <tf.Tensor: shape=(), dtype=int64, numpy=0>)
  19. (<tf.Tensor: shape=(), dtype=string, numpy=b"Such now appears th' o'er-ruling sov'reign will">, <tf.Tensor: shape=(), dtype=int64, numpy=1>)
  20. (<tf.Tensor: shape=(), dtype=string, numpy=b'Them so prepared the King of men beheld'>, <tf.Tensor: shape=(), dtype=int64, numpy=0>)
  21. (<tf.Tensor: shape=(), dtype=string, numpy=b'mourn you, but the eddies of Scamander shall bear you into the broad'>, <tf.Tensor: shape=(), dtype=int64, numpy=2>)
  22. (<tf.Tensor: shape=(), dtype=string, numpy=b'there was no life left in him.'>, <tf.Tensor: shape=(), dtype=int64, numpy=2>)
  23. '''

将文本编码成数字：

  1. # 1. 建立词汇表
  2. # 1.1 迭代每个样本的 numpy 值
  3. # 1.2 使用 tfds.features.text.Tokenizer 来将其分割成 token
  4. tokenizer = tfds.features.text.Tokenizer()
  5.  
  6. # 1.3 将 token 放入一个python集合中消除重复项
  7. vocabulary_set = set()
  8. for text_tensor, _ in all_labeled_data:
  9.   some_tokens = tokenizer.tokenize(text_tensor.numpy())
  10.   vocabulary_set.update(some_tokens)
  11.  
  12. # 1.4 获取该词汇表的大小
  13. vocab_size = len(vocabulary_set)
  14. vocab_size
  15. # 17178
  16.  
  17. # 2. 样本编码
  18. # 向编码器的encode方法传入一行文本后返回一个整数列表
  19. # 2.1 构建编码器
  20. encoder = tfds.features.text.TokenTextEncoder(vocabulary_set)
  21.  
  22. # 2.2 运行编码器
  23. # 将编码器打包到 tf.py_function 并且传参至数据集的 map 方法在数据集上运行编码器
  24. # tf.py_function 将计算图表示为 python 函数
  25. # tf.py_function(func,inp,Tout,name=None)，func是一个python函数，接受inp作为参数返回一个Tout类型的输出
  26. def encode(text_tensor, label):
  27.   encoded_text = encoder.encode(text_tensor.numpy())
  28.   return encoded_text, label
  29.  
  30. def encode_map_fn(text, label):
  31.   encoded_text, label = tf.py_function(encode, 
  32.                                        inp=[text, label], 
  33.                                        Tout=(tf.int64, tf.int64))
  34.  
  35.   encoded_text.set_shape([None])
  36.   label.set_shape([])
  37.  
  38.   return encoded_text, label
  39.  
  40.  
  41. all_encoded_data = all_labeled_data.map(encode_map_fn)

将数据集分割成测试集和训练集并分batch：

使用 tf.data.Dataset.take 和 tf.data.Dataset.skip 来建立一个小一些的测试数据集和稍大一些的训练数据集。在数据集被传入模型之前，数据集需要被分批。每个分支中的样本大小与格式需要一致，但是数据集中样本并不全是相同大小的（每行文本字数并不相同）。因此，使用 tf.data.Dataset.padded_batch（而不是 batch ）将样本填充到相同的大小。

  1. train_data = all_encoded_data.skip(TAKE_SIZE).shuffle(BUFFER_SIZE)
  2. train_data = train_data.padded_batch(BATCH_SIZE)
  3.  
  4. test_data = all_encoded_data.take(TAKE_SIZE)
  5. test_data = test_data.padded_batch(BATCH_SIZE)
  6.  
  7. # 查看测试集
  8. sample_text, sample_labels = next(iter(test_data))
  9.  
  10. sample_text[0], sample_labels[0]
  11.  
  12. '''
  13. (<tf.Tensor: shape=(16,), dtype=int64, numpy=
  14.  array([15746, 11433,  8394,  9006,   379,  3463, 17072,     0,     0,
  15.             0,     0,     0,     0,     0,     0,     0])>,
  16.  <tf.Tensor: shape=(), dtype=int64, numpy=0>)
  17. '''
  18.  
  19. # 现在，test_data 和 train_data 不是（example, label）对的集合，而是批次的集合
  20. # 每个批次都是一对（多样本, 多标签），表示为数组
  21.  
  22. # 由于引入了一个新的 token 来编码，因此词汇表大小增加了一个
  23. vocab_size += 1

6.4 构建模型

  1. model = tf.keras.Sequential()
  2.  
  3. # Embedding层将整数表示转换为密集矢量嵌入
  4. model.add(tf.keras.layers.Embedding(vocab_size, 64))
  5.  
  6. # LSTM 层允许模型利用上下文中理解单词含义
  7. model.add(tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(64)))
  8.  
  9. # 一个或多个紧密连接的层
  10. # 编辑 `for` 行的列表去检测层的大小
  11. for units in [64, 64]:
  12.   model.add(tf.keras.layers.Dense(units, activation='relu'))
  13.  
  14. # 输出层，第一个参数是标签个数。
  15. model.add(tf.keras.layers.Dense(3, activation='softmax'))
  16.  
  17. # 编译模型
  18. model.compile(optimizer='adam',
  19.               loss='sparse_categorical_crossentropy',
  20.               metrics=['accuracy'])

6.5 训练模型

  1. model.fit(train_data, epochs=3, validation_data=test_data)
  2.  
  3. eval_loss, eval_acc = model.evaluate(test_data)
  4.  
  5. print('\nEval loss: {}, Eval accuracy: {}'.format(eval_loss, eval_acc))
  6.  
  7. '''
  8. 79/79 [==============================] - 1s 18ms/step - loss: 0.3794 - accuracy: 0.8246
  10. Eval loss: 0.3794495761394501, Eval accuracy: 0.8245999813079834
  11. '''
声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号