• 深度学习基础之《TensorFlow框架（13）—二进制数据》

    一、CIFAR-10二进制数据集介绍

    1、CIFAR-10数据集
    CIFAR-10数据集由10个类别的60000个32x32彩色图像组成，每个类别有6000个图像。有50000个训练图像和10000个测试图像

    2、数据集分为五个训练批次和一个测试批次，每个批次有10000个图像

    3、data_batch_1.bin 到 data_batch_5.bin 训练集

    4、test_batch.bin 测试集

    5、这些类别完全相互互斥，汽车和卡车之间没有重叠。汽车包括轿车、SUV，卡车只包括大卡车

    6、二进制数据文件内容格式
    二进制数据文件包含data_batch_1.bin 到 data_batch_5.bin、test_batch.bin

    这些文件中每一个格式如下，数据中每个样本包含了特征值和目标值：
    <1x标签> <3072x像素>
    ...
    <1x标签> <3072x像素>

    每3073个字节是一个样本：
    1个目标值+3072个像素

    7、格式说明
    第一个字节，是第一个图像的标签（目标值：飞机是0，汽车是2，鸟是3。。。），它是一个0-9范围内的数字。接下来的3072个字节是图像像素的值。前1024个字节是红色通道值，下1024个是绿色通道值，最后1024个是蓝色通道值
    值以行优先顺序存储，因此前32个字节是图像第一行的红色通道值
    每个文件都包含10000个这样的3073字节的“行”图像，但没有任何分隔行的限制。因此每个文件应该完全是30730000字节长

    二、CIFAR-10二进制数据读取

    1、分析
    （1）构造文件名列表
    （2）读取二进制数据并进行解码
    （3）将数据的标签和图片进行分割
        对tensor对象进行切片
        label
        一个样本image(3072字节 = 1024r + 1024g + 1024b)
        [[1024r],
        [1024g],
        [1024b]]
        shape = (3, 32, 32) = (channels, height, width)
        因为tensorflow的图像表示习惯是(height, width, channel)
        所以需要转换
    （4）处理图片数据形状以及数据类型
    （5）运行

    2、代码day02_binary_read.py

    1. import os
    2. os.environ['TF_CPP_MIN_LOG_LEVEL']='2'
    3. import tensorflow as tf
    4.  
    5. class Cifar(object):
    6.  
    7.     def __init__(self):
    8.  
    9.         # 初始化操作
    10.         self.height = 32
    11.         self.width = 32
    12.         self.channels = 3
    13.  
    14.         # 字节数
    15.         self.image_bytes = self.height * self.width * self.channels
    16.         self.label_bytes = 1
    17.         self.all_bytes = self.label_bytes + self.image_bytes
    18.  
    19.     def read_and_decode(self):
    20.  
    21.         decoded_data = []
    22.  
    23.         # 1、构造文件名列表
    24.         filenames = tf.data.Dataset.list_files("./cifar-10-batches-bin/data_batch_*.bin")
    25.         for filename in filenames:
    26.             print(filename)
    27.  
    28.         # 2、读取与解码
    29.         for filename in filenames:
    30.             raw = tf.io.read_file(filename)
    31.             # 解码为一维的uint8数组
    32.             data = tf.io.decode_raw(raw, out_type=tf.uint8)
    33.             print(data)
    34.             decoded_data.append(data)
    35.  
    36.         # 3、运行
    37.         # 将文件按照样本切片切开
    38.         for data in decoded_data:
    39.             for i in range(10000):
    40.                 cut_data = tf.slice(data, [i*self.all_bytes], [self.all_bytes])
    41.                 #print(cut_data)
    42.                 label = tf.slice(cut_data, [0], [self.label_bytes])
    43.                 image = tf.slice(cut_data, [self.label_bytes], [self.image_bytes])
    44.                 #print("label: ", label)
    45.                 #print("image: ", image)
    46.                 # 调整图片形状
    47.                 image_reshaped = tf.reshape(image, shape=[self.channels, self.height, self.width])
    48.                 #print("image_reshaped: ", image_reshaped)
    49.                 # 转置，将图片顺序转为height, width, channels
    50.                 image_transposed = tf.transpose(image_reshaped, [1, 2, 0])
    51.                 #print("image_transposed: ", image_transposed)
    52.                 # 调整图像类型
    53.                 image_cast = tf.cast(image_transposed, tf.float32)
    54.                 print("image_cast: ", image_cast)
    55.  
    56.         return None
    57.  
    58.  
    59. if __name__ == "__main__":
    60.  
    61.     # 实例化Cifar
    62.     cifar = Cifar()
    63.     cifar.read_and_decode()

    filename打印例子：

    1. tf.Tensor(b'./cifar-10-batches-bin/data_batch_4.bin', shape=(), dtype=string)
    2. tf.Tensor(b'./cifar-10-batches-bin/data_batch_3.bin', shape=(), dtype=string)
    3. tf.Tensor(b'./cifar-10-batches-bin/data_batch_1.bin', shape=(), dtype=string)
    4. tf.Tensor(b'./cifar-10-batches-bin/data_batch_2.bin', shape=(), dtype=string)
    5. tf.Tensor(b'./cifar-10-batches-bin/data_batch_5.bin', shape=(), dtype=string)

    解码后打印例子：

    1. tf.Tensor([  8  26  17 ... 127 124 116], shape=(30730000,), dtype=uint8)
    2. tf.Tensor([  6  59  43 ... 130 130 131], shape=(30730000,), dtype=uint8)
    3. tf.Tensor([  0 178 178 ... 182 175 174], shape=(30730000,), dtype=uint8)
    4. tf.Tensor([  1  35  27 ... 119 127 136], shape=(30730000,), dtype=uint8)
    5. tf.Tensor([  1 255 252 ... 173 162 161], shape=(30730000,), dtype=uint8)

    切片后打印例子：

    1. label:  tf.Tensor([6], shape=(1,), dtype=uint8)
    2. image:  tf.Tensor([255 254 255 ...  79  81  76], shape=(3072,), dtype=uint8)

    调整图片形状后打印例子：

    1. image_reshaped:  tf.Tensor(
    2. [[[229 236 234 ... 217 221 222]
    3.   [222 239 233 ... 223 227 210]
    4.   [213 234 231 ... 220 220 202]
    5.   ...
    6.   [150 140 132 ... 224 230 241]
    7.   [137 130 125 ... 181 202 212]
    8.   [122 118 120 ... 179 164 163]]
    9.  
    10.  [[229 237 236 ... 219 223 223]
    11.   [221 239 234 ... 223 228 211]
    12.   [206 232 233 ... 220 219 203]
    13.   ...
    14.   [143 135 127 ... 222 228 241]
    15.   [132 127 121 ... 180 201 211]
    16.   [119 116 116 ... 177 164 163]]
    17.  
    18.  [[239 247 247 ... 233 234 233]
    19.   [229 249 246 ... 236 238 220]
    20.   [211 239 244 ... 232 232 215]
    21.   ...
    22.   [135 127 120 ... 218 225 238]
    23.   [126 120 115 ... 178 198 207]
    24.   [114 110 111 ... 173 162 161]]], shape=(3, 32, 32), dtype=uint8)

    转置后打印例子：

    1. image_transposed:  tf.Tensor(
    2. [[[235 252 252]
    3.   [239 251 251]
    4.   [239 251 251]
    5.   ...
    6.   [225 251 252]
    7.   [228 251 252]
    8.   [228 252 252]]
    9.  
    10.  [[249 255 255]
    11.   [251 253 255]
    12.   [252 254 255]
    13.   ...
    14.   [229 255 255]
    15.   [231 255 255]
    16.   [232 255 255]]
    17.  
    18.  [[241 250 254]
    19.   [243 248 252]
    20.   [245 248 252]
    21.   ...
    22.   [231 253 251]
    23.   [232 253 252]
    24.   [233 253 252]]
    25.  
    26.  ...
    27.  
    28.  [[ 81 118 176]
    29.   [ 85 123 178]
    30.   [ 83 123 175]
    31.   ...
    32.   [167 167 168]
    33.   [168 168 170]
    34.   [165 166 169]]
    35.  
    36.  [[ 79 119 176]
    37.   [ 69 108 163]
    38.   [ 67 105 158]
    39.   ...
    40.   [170 172 174]
    41.   [163 164 167]
    42.   [161 164 169]]
    43.  
    44.  [[ 46  87 142]
    45.   [ 45  83 137]
    46.   [ 52  88 141]
    47.   ...
    48.   [175 179 182]
    49.   [168 172 175]
    50.   [163 169 174]]], shape=(32, 32, 3), dtype=uint8)

    调整图像类型后打印例子：

    1. image_cast:  tf.Tensor(
    2. [[[229. 229. 239.]
    3.   [236. 237. 247.]
    4.   [234. 236. 247.]
    5.   ...
    6.   [217. 219. 233.]
    7.   [221. 223. 234.]
    8.   [222. 223. 233.]]
    9.  
    10.  [[222. 221. 229.]
    11.   [239. 239. 249.]
    12.   [233. 234. 246.]
    13.   ...
    14.   [223. 223. 236.]
    15.   [227. 228. 238.]
    16.   [210. 211. 220.]]
    17.  
    18.  [[213. 206. 211.]
    19.   [234. 232. 239.]
    20.   [231. 233. 244.]
    21.   ...
    22.   [220. 220. 232.]
    23.   [220. 219. 232.]
    24.   [202. 203. 215.]]
    25.  
    26.  ...
    27.  
    28.  [[150. 143. 135.]
    29.   [140. 135. 127.]
    30.   [132. 127. 120.]
    31.   ...
    32.   [224. 222. 218.]
    33.   [230. 228. 225.]
    34.   [241. 241. 238.]]
    35.  
    36.  [[137. 132. 126.]
    37.   [130. 127. 120.]
    38.   [125. 121. 115.]
    39.   ...
    40.   [181. 180. 178.]
    41.   [202. 201. 198.]
    42.   [212. 211. 207.]]
    43.  
    44.  [[122. 119. 114.]
    45.   [118. 116. 110.]
    46.   [120. 116. 111.]
    47.   ...
    48.   [179. 177. 173.]
    49.   [164. 164. 162.]
    50.   [163. 163. 161.]]], shape=(32, 32, 3), dtype=float32)

    3、切片函数
    tf.slice(inputs, begin, size, name=None)
    说明：
    inputs：输入的数组
    begin：表示从inputs的哪几个维度上的哪个元素开始抽取，元素的索引
    size：表示在inputs的各个维度上抽取的元素个数，要切多长

    1. In [1]: import tensorflow as tf
    2.  
    3. In [2]: a = tf.constant([0,1,2,3,4,5,6,7,8,9])
    4.  
    5. In [3]: a
    6. Out[3]: 10,), dtype=int32, numpy=array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=int32)>
    7.  
    8. In [4]: tf.slice(a, [4], [3])
    9. Out[4]: 3,), dtype=int32, numpy=array([4, 5, 6], dtype=int32)>
    10.  
    11. In [5]: b = tf.constant([[1,2,3],[4,5,6]])
    12.  
    13. In [6]: b
    14. Out[6]: 
    15. 2, 3), dtype=int32, numpy=
    16. array([[1, 2, 3],
    17.        [4, 5, 6]], dtype=int32)>
    18.  
    19. In [7]: tf.slice(b, [0,1], [2,1])
    20. Out[7]: 
    21. 2, 1), dtype=int32, numpy=
    22. array([[2],
    23.        [5]], dtype=int32)>

    第一个例子，[0,1,2,3,4,5,6,7,8,9]从第4个索引位置，截取3个长度，所以是[4,5,6]
    第二个例子，[[1,2,3],[4,5,6]]是从0行1列开始，就是[1,2,3]的2，对x的第一个维度（行）抽取2个元素，在对x的第二个维度（列）抽取1个元素，所以是[2,5]

    4、NHWC和NCHW
    这里的图片形状设置从1维的排列到3维数据的时候，涉及到NHWC与NCHW的概念

    在读取设置图片形状的时候有两种格式：
    设置为“NHWC”时，排列顺序为 [batch, height, width, channels]
    设置为“NCHW”时，排列顺序为 [batch, channels, height, width]
    其中N表示这批图像有几张，H表示图像在竖直方向有多少像素，W表示水平方向像素，C表示通道数

    tensorflow默认的是[height, width, channels]

    假设RGB三通道两种格式的区别如下图所示：

    理解
    假设1,2,3,4-红色，5,6,7,8-绿色，9,10,11,12-蓝色
    （1）如果通道在最低维度0[channel, height, width]，RGB三颜色分成三组，在第一维度上找到三个RGB颜色（NCHW）
    （2）如果通道在最高维度2[height, width, channel]，在第三维度上找到RGB三个颜色（NHWC）

    5、tf.transpose(image_reshaped, [1, 2, 0])
    [1, 2, 0]表示，原来在1号位置的现在在0号位置，原来在2号位置的在1号位置，原来在0号位置的在1号位置

    参考资料：
    https://blog.csdn.net/Aidam_Bo/article/details/91908637
    https://blog.csdn.net/weixin_41845265/article/details/107067012
     

  • 相关阅读:
    Spring循环依赖
    box-sizing: border-box；box-sizing:content-box；讲解
    零基础转行网络安全，难度大吗？
    ChatGPT首次被植入人类大脑：帮助残障人士开启对话
    【数据结构基础_字符串】Leetcode 409.最长回文串
    spring-boot-starter-data-redis 引发的一系列惨案
    webpack--打包入口(entry)
    Linux中对磁盘(硬盘)分区和挂载
    Ubuntu22.04安装MySql
    【CVPR 2021】Cylinder3D：用于LiDAR点云分割的圆柱体非对称3D卷积网络
  • 原文地址：https://blog.csdn.net/csj50/article/details/138084910