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

有一个关于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)

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 ]才可以运行成功