mnist的格式说明，以及在python3.x和python 2.x读取mnist数据集的不同

mnist数据集的读取，mnist数据的格式说明，以及struct的介绍

有一个关于mnist的一个事例可以参考，我觉得写的很好：http://www.cnblogs.com/x1957/archive/2012/06/02/2531503.html
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import struct
# from bp import *
from datetime import datetime
# 数据加载器基类
class Loader(object):
    def __init__(self, path, count):
        \’\’\’
        初始化加载器
        path: 数据文件路径
        count: 文件中的样本个数
        \’\’\’
        self.path = path
        self.count = count
    def get_file_content(self):
        \’\’\’
        读取文件内容
        \’\’\’
        f = open(self.path, \’rb\’)
        content = f.read()
        print content[:20]
        f.close()
        return content
 
    def to_int(self,h):
        return struct.unpack(\’B\’,h)[0]
 
# 图像数据加载器
class ImageLoader(Loader):
    def get_picture(self, content, index):
        \’\’\’
        内部函数，从文件中获取图像
        \’\’\’
        start = index * 28 * 28 + 16
        picture = []
        # print(content[16])
        for i in range(28):
            picture.append([])
            for j in range(28):
                picture[i].append(
#在python2.7中，红色字体部分就是对的，但是在python3.x中，蓝色字体才是对的
                    self.to_int(content[start + i * 28 + j-1:start + i * 28 + j ]))
                    self.to_int(content[start + i * 28 + j]))
        return picture
    def get_one_sample(self, picture):
        \’\’\’
        内部函数，将图像转化为样本的输入向量
        \’\’\’
        sample = []
        for i in range(28):
            for j in range(28):
                sample.append(picture[i][j])
        return sample
    def load(self):
        \’\’\’
        加载数据文件，获得全部样本的输入向量
        \’\’\’
        content = self.get_file_content()
        data_set = []
        for index in range(self.count):
            data_set.append(
                self.get_one_sample(
                    self.get_picture(content, index)))
        return data_set
# 标签数据加载器
class LabelLoader(Loader):
    def load(self):
        \’\’\’
        加载数据文件，获得全部样本的标签向量
        \’\’\’
        content = self.get_file_content()
        # print content[:15]
        labels = []
        for index in range(self.count):
#在python2.7中，红色字体部分就是对的，但是在python3.x中，蓝色字体才是对的
            labels.append(self.norm(content[index + 7 :index + 8]))
            labels.append(self.norm(content[index + 8]))
        return labels
    def norm(self, label):
        \’\’\’
        内部函数，将一个值转换为10维标签向量
        \’\’\’
        label_vec = []
        # print(\’label is \n\’)
        # print(label[:20])
        label_value = self.to_int(label)
        for i in range(10):
            if i == label_value:
                label_vec.append(0.9)
            else:
                label_vec.append(0.1)
        return label_vec
def get_training_data_set():
    \’\’\’
    获得训练数据集
    \’\’\’
    filename1 = r\’E:\workspace\pythonpaper\importment\dataset\train-images.idx3-ubyte\’
    filename2 = r\’E:\workspace\pythonpaper\importment\dataset\train-labels.idx1-ubyte\’
    image_loader = ImageLoader(filename1, 60000)
    label_loader = LabelLoader(filename2, 60000)
    return image_loader.load(), label_loader.load()
def get_test_data_set():
    \’\’\’
    获得测试数据集
    \’\’\’
    filename3 = r\’E:\workspace\pythonpaper\importment\dataset\t10k-images.idx3-ubyte\’
    filename4 = r\’E:\workspace\pythonpaper\importment\dataset\t10k-labels.idx1-ubyte\’
    image_loader = ImageLoader(filename3, 10000)
    label_loader = LabelLoader(filename4, 10000)
    return image_loader.load(), label_loader.load()
 
def train_and_evaluate():
 
    train_data_set, train_labels = get_training_data_set()
    test_data_set, test_labels = get_test_data_set()
    # print \'[dataset train:]\n\’
    # print train_data_set[:10]
 
if __name__ == \’__main__\’:
    train_and_evaluate()
 
1、mnist数据集格式的介绍 
上面的代码是我参考的一个教程上的例子，它本身是用python2.7实现的，但是，因为一些原因，我用的python3.5的环境，在实现这个代码的时候，出现了一些问题，为此，我也探究了一下。
mnist数据集是一个idx的文件格式，从网上下载下来的是四个压缩文件，两个训练样本的压缩文件，两个测试样本的压缩文件，在导入代码之前需要把它们解压缩，解压后的文件是以idx3-ubyte为后缀的idx的文件，这个文件是不能直接打开的，所以我们需要编写程序把它处理成我们需要的内容。
以mnist数据集的train-images-idx3-ubyte为例介绍

TRAINING SET IMAGE FILE (train-images-idx3-ubyte):

[offset] [type]          [value]          [description] 
0000     32 bit integer  0x00000803(2051) magic number 
0004     32 bit integer  60000            number of images 
0008     32 bit integer  28               number of rows 
0012     32 bit integer  28               number of columns 
0016     unsigned byte   ??               pixel 
0017     unsigned byte   ??               pixel 
........ 

xxxx     unsigned byte   ??               pixel
32bit是说这个数据书32位的，8位=1B（1个字节），因此，32位=4B=4byte，我们真正要读出来的是value这一列，但是0000-0015的数据不是我们需要的，第一个4B是magic的数量，第二个4B是这个文件包含多少个图像，第三个4B是说一个图像的有多少行，第四个4B是说一个图像有多少列，mnist的一个样本图像是28*28的。从0016开始，才是我们需要的图像内容，28*28=784，也就是我们需要784个B才能读取一个图像，在0016以下的的description上，写的是pixel，这是像素的意思，也就是说，一个像素就是一个1byte=1B，举例，用1B（一个字节）的二进制表示一个十进制的3，二进制就是0000 0011，用十六进制表示3，就是\x03，3的缩写是ETX。这样784个像素，784行就是一个图像样本了。
下面是mnist数据集的train-labels-idx1-ubyte文件的结构
TRAINING SET LABEL FILE (train-labels-idx1-ubyte):
    [offset] [type]          [value]          [description]
    0000     32 bit integer  0x00000801(2049) magic number (MSB first)
    0004     32 bit integer  60000            number of items
    0008     unsigned byte   ??               label
    0009     unsigned byte   ??               label
    ........

    xxxx     unsigned byte   ??               label
train-labels-idx1-ubyte文件的结构的读法和train-images-idx3-ubyte相同，前8个字节不是label的内容，从0008开始才是一个label的内容，而且，通过观察这个表格的offset和description字段可以发现，一个字节是一个label。
 
 2、像素和二进制，十六进制的关系，以及python中print 的输出的不同
先说明一下二进制和十六进制和十进制的关系，以及它们的缩写的关系
ASCII控制字符
二进制 十进制 十六进制 缩写 可以显示的表示法 名称/意义
0000 0000 0 00 NUL ␀ 空字符（Null）
0000 0001 1 01 SOH ␁ 标题开始
0000 0010 2 02 STX ␂ 本文开始
0000 0011 3 03 ETX ␃ 本文结束
0000 0100 4 04 EOT ␄ 传输结束
0000 0101 5 05 ENQ ␅ 请求
0000 0110 6 06 ACK ␆ 确认回应
0000 0111 7 07 BEL ␇ 响铃
0000 1000 8 08 BS ␈ 退格
0000 1001 9 09 HT ␉ 水平定位符号
0000 1010 10 0A LF ␊ 换行键
0000 1011 11 0B VT ␋ 垂直定位符号
0000 1100 12 0C FF ␌ 换页键
 
从open（filepath,\’rb\’）中读出来的是二进制的内容，print content[:5]，显示content的前5个元素，一个元素就是一个像素，这样就有5个像素，而一个像素占一个二进制，一个二进制就是一个字节，一个字节就是一个十六进制。
 
有个小例子可以进一步说明一个int包含了4个字节，而一个字节是\x14这样的形式。
>>> a=20
>>> b=400
>>> t=struct.pack(\’ii\’,a,b)
>>> t
\’\x14\x00\x00\x00\x90\x01\x00\x00\’
>>> len(t)
8
>>> type(a)
<type \’int\’>
a是int型的，pack(\’ii\’,a,b)中的\’ii\’是格式，一个i对应了一个int，有两个i，对应了两个int，一个int型的a，占了4个字节（\x14\x00\x00\x00），len输出的是一个字节\x14就是一个，所有有8个\x这样的，len(t)就是8个
 
3、struct的介绍
a=20,b=400
struct有三个方法，pack(fmt,val)方法是把val的数据按照fmt的格式转换为二进制数据， t=struct.pack(\’ii\’,a,b)，把a,b转换为二进制形式\’\x14\x00\x00\x00\x90\x01\x00\x00\’
unpack(fmt,val)方法是把val按照fmt的格式把二进制数据转换为python可以读的数据，unpack(\’ii\’,a,b)，把a,b转换为20,400
struct.unpack_from(\'>IIII\' , buf , index)\'>IIII\'是说使用大端法从index的位置读取4个unsinged int32
 
4、python2.7和python3.5对mnist数据集的格式引发的问题
在python2.7中，content输出的是20个二进制的缩写，但是在python3.5中，print content[:20]输出的是20个十六进制。
在python2.7中，在struct.unpack(\’B\’,byte)中的content[start+i*28+j]，就可以运行，但是在python3中，这里就需要写成[start+i*28+j -1:start+i*28+j ]才可以运行成功
 

版权声明：本文为yingchuan-hxf原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/yingchuan-hxf/p/6732604.html