В предыдущей статье мы описали процесс эксперимента MNIST, но после того, как мы закончили эксперимент, мы мало что узнали, мы знали только конкретное использование Tensorflow, поэтому в этой статье объясняется конкретное содержание этого эксперимента и анализируется Эксперимент MNIST в деталях, если вы сначала прочитаете эту статью, а затем проведете эксперимент MNIST, он может быть более глубоким.
«Машинное обучение Tensorflow Notes 1: Hello World to MNIST Experiment»
описание файла
Этот сжатый пакет представляет собой самую авторитетную в мире библиотеку распознавания рукописных цифр, разработанную почтовой системой США.Рукописный контент представляет собой содержимое от 0 до 9.Рукописный контент собран у сотрудников и старшеклассников переписи населения США. Бюро.официальный сайт МНИСТДля начала загрузите эти четыре файла, конкретные инструкции этих четырех файлов:
There are 4 files:
train-images-idx3-ubyte: training set images
train-labels-idx1-ubyte: training set labels
t10k-images-idx3-ubyte: test set images
t10k-labels-idx1-ubyte: test set labels
The training set contains 60000 examples, and the test set 10000 examples.
Эксперимент MINIST состоит из четырех файлов, из которыхtrain-images-idx3-ubyteпредставляет собой образец из 60 000 изображений и состоит из,train-labels-idx1-ubyteцифровая метка, соответствующая этим 60 000 изображений,t10k-images-idx3-ubyteобразец, используемый для тестирования,t10k-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
The labels values are 0 to 9.
Как видно из описания, файл имеет бинарное содержимое, из них 0-4 бита (магическое число), это описание протокола файла, это значение должно быть2049, при чтении информации о файле ее можно проверить, чтобы не было проблем с файлом.Конечно, экспериментировать не обязательно, 4-8 бит описывают всего 60 000 выборочных данных в файле, с 9 до конца, каждый бит представляет цифровую информацию набора данных.
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
Pixels are organized row-wise. Pixel values are 0 to 255. 0 means background (white), 255 means foreground (black).
TEST SET LABEL FILE (t10k-labels-idx1-ubyte):
[offset] [type] [value] [description]
0000 32 bit integer 0x00000801(2049) magic number (MSB first)
0004 32 bit integer 10000 number of items
0008 unsigned byte ?? label
0009 unsigned byte ?? label
........
xxxx unsigned byte ?? label
The labels values are 0 to 9.
TEST SET IMAGE FILE (t10k-images-idx3-ubyte):
[offset] [type] [value] [description]
0000 32 bit integer 0x00000803(2051) magic number
0004 32 bit integer 10000 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
Pixels are organized row-wise. Pixel values are 0 to 255. 0 means background (white), 255 means foreground (black).
разбор файла
Теперь, когда мы знаем конкретное описание содержимого файла, мы можем начать синтаксический анализ файла, чтобы увидеть конкретное содержимое. Скачанный нами файл.gzСуффикс указывает, что это сжатый файл.Когда мы разрабатываем код, нам нужно подумать о распаковке файла.
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import gzip
import sys
import struct
train_images = "MNIST_data/train-images-idx3-ubyte.gz"
train_labels = "MNIST_data/train-labels-idx1-ubyte.gz"
t10k_images = "MNIST_data/t10k-images-idx3-ubyte.gz"
t10k_labels = "MNIST_data/t10k-labels-idx1-ubyte.gz"
def read_labels(filename):
labels = []
with gzip.open(filename) as bytestream:
index = 0
buf = bytestream.read()
bytestream.close()
# 根据MINIST文件的描述，文件开始是用于校验的数字，`integer`格式，占用4个字节，位于0-4位置
# 第二个描述文件的内容数量，`integer`格式，占用4个字节，位置4-8位置
magic, numberOfLabels = struct.unpack_from('>II', buf, index)
print(magic)
print(numberOfLabels)
# index += struct.calcsize('>II') #这里的结果是 +=8，为了直观，就直接填写8
# 因为magic, numberOfLabels 占据前面8个字节，所以把下标移动到第 8 位，开始读取数字标签的内容
index = 8
while index < numberOfLabels:
# 根据MINIST文件的描述，labels的数字是`unsigned byte`格式，占用一个字节，所以这里填写`B`
num = int(struct.unpack_from('B', buf, index)[0])
labels.append(num)
# index += struct.calcsize('B')
# 移动到下一个光标
index += 1
return labels
def read_images(filename, labels):
# 把文件解压成字节流
with gzip.open(filename) as bytestream:
index = 0
buf = bytestream.read()
bytestream.close()
# 根据MINIST文件的描述，文件开始是用于校验的数字，`integer`格式，占用4个字节，位于0-4位置
# 第二个描述文件的内容数量，`integer`格式，占用4个字节，位置4-8位置
magic, numberOfImages, rows, columns = struct.unpack_from('>IIII', buf, index)
print(magic)
print(numberOfImages)
print(rows)
print(columns)
# index += struct.calcsize('>IIII') #这里的结果是 +=16，为了直观，就直接填写16
# 因为magic, numberOfImages, rows, columns 占据前面16个字节，所以把下标移动到第 16 位，开始读取数字标签的内容
index = 16
for i in xrange(numberOfImages):
# for i in xrange(5):
# 打印对应的数字标签
print(labels[i])
for x in xrange(rows):
for y in xrange(columns):
num = int(struct.unpack_from('B', buf, index)[0])
if num > 100:
sys.stdout.write(str(num)+" ")
elif num > 50:
sys.stdout.write(str(num)+" ")
else:
sys.stdout.write(str('0 '))
index += 1
sys.stdout.write(str('\n'))
sys.stdout.write(str('\n'))
sys.stdout.flush()
return
# 解析labels的内容，train_labels包含了60000个数字标签，返回60000个数字标签的数组
labels = read_labels(train_labels)
print(labels)
read_images(train_images, labels)
если мы пройдемprint(labels)Выведите содержимое этикеток, и вы увидите, что это массив, содержащий 60 000 чисел, массивы все от 0 до 9, и этот массив соответствует образцам изображений один к одному.
Запускаем код, делаем скриншот первого образца изображения, текст первого изображения5, каждый пиксель изображения представляет собой немаркированное число (0~254)
Если написать пиксели как картинку, то картинка будет выглядеть так:
Для большего количества картинок я не буду здесь представлять, как написать файл картинки, а приведу код для самостоятельного изучения:
from PIL import Image
import struct
import gzip
def read_image(filename):
with gzip.open(filename) as bytestream:
index = 0
buf = bytestream.read()
bytestream.close()
magic, images, rows, columns = struct.unpack_from('>IIII', buf, index)
index += struct.calcsize('>IIII')
for i in xrange(images):
image = Image.new('RGB', (columns, rows))
for x in xrange(rows):
for y in xrange(columns):
image.putpixel((y, x), int(struct.unpack_from('>B', buf, index)[0]))
index += struct.calcsize('>B')
print 'save ' + str(i) + 'image'
# 请手动创建test文件夹，图片文件要写入文件夹中
image.save('test/' + str(i) + '.png')
return
read_image("MNIST_data/train-images-idx3-ubyte.gz")
Вернуться к Тензорфлоу
Из вышеизложенного мы уже знаем конкретное содержимое этих файлов, поэтому давайте вернемся к Tensorflow, чтобы посмотреть, как Tensorflow обучает модель.
делай по-своему
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import gzip
import sys
import struct
train_images_file = "MNIST_data/train-images-idx3-ubyte.gz"
train_labels_file = "MNIST_data/train-labels-idx1-ubyte.gz"
t10k_images_file = "MNIST_data/t10k-images-idx3-ubyte.gz"
t10k_labels_file = "MNIST_data/t10k-labels-idx1-ubyte.gz"
def read_labels(filename):
labels = []
with gzip.open(filename) as bytestream:
index = 0
buf = bytestream.read()
bytestream.close()
# 根据MINIST文件的描述，文件开始是用于校验的数字，`integer`格式，占用4个字节，位于0-4位置
# 第二个描述文件的内容数量，`integer`格式，占用4个字节，位置4-8位置
magic, numberOfLabels = struct.unpack_from('>II', buf, index)
print(magic)
print(numberOfLabels)
# index += struct.calcsize('>II') #这里的结果是 +=8，为了直观，就直接填写8
# 因为magic, numberOfLabels 占据前面8个字节，所以把下标移动到第 8 位，开始读取数字标签的内容
index = 8
while len(labels) < numberOfLabels:
# 根据MINIST文件的描述，labels的数字是`unsigned byte`格式，占用一个字节，所以这里填写`B`
num = int(struct.unpack_from('B', buf, index)[0])
tmp =[0,0,0,0,0,0,0,0,0,0]
tmp[num] = 1
labels.append(tmp)
# index += struct.calcsize('B')
# 移动到下一个光标
index += 1
return labels
def read_images(filename, labels):
images = []
# 把文件解压成字节流
with gzip.open(filename) as bytestream:
index = 0
buf = bytestream.read()
bytestream.close()
# 根据MINIST文件的描述，文件开始是用于校验的数字，`integer`格式，占用4个字节，位于0-4位置
# 第二个描述文件的内容数量，`integer`格式，占用4个字节，位置4-8位置
magic, numberOfImages, rows, columns = struct.unpack_from('>IIII', buf, index)
print(magic)
print(numberOfImages)
print(rows)
print(columns)
# index += struct.calcsize('>IIII') #这里的结果是 +=16，为了直观，就直接填写16
# 因为magic, numberOfImages, rows, columns 占据前面16个字节，所以把下标移动到第 16 位，开始读取数字标签的内容
index = 16
for i in xrange(numberOfImages):
# 打印对应的数字标签
image = []
for x in xrange(rows):
row = []
for y in xrange(columns):
num = int(struct.unpack_from('B', buf, index)[0])
image.append(float(num/255.0))
index += 1
images.append(image)
return images
# 解析labels的内容，train_labels包含了60000个数字标签，返回60000个数字标签的数组
train_labels = read_labels(train_labels_file)
# print(labels)
train_images = read_images(train_images_file, train_labels)
test_labels = read_labels(t10k_labels_file)
# print(labels)
test_images = read_images(t10k_images_file, test_labels)
import tensorflow as tf
x = tf.placeholder("float", [None,784.])
W = tf.Variable(tf.zeros([784.,10.]))
b = tf.Variable(tf.zeros([10.]))
y = tf.nn.softmax(tf.matmul(x,W) + b)
y_ = tf.placeholder("float")
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(600):
print(i)
batch_xs = train_images[100*i:100*i+100]
batch_ys = train_labels[100*i:100*i+100]
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print sess.run(accuracy, feed_dict={x: test_images, y_: test_labels})
Запустите код, подождите несколько минут, чтобы увидеть результат, правильная скорость0.897
Но когда это слишком медленно, эффективность слишком низкая, в основном, когда объединение массивов изображений слишком медленное, это заняло около трех минут, мы улучшили эффективность обработки, внедрив NumPy, обратитесь к официальному примеру для преобразования.
#!/usr/bin/python
# -*- coding: UTF-8 -*-
import gzip
import sys
import struct
import numpy
train_images_file = "MNIST_data/train-images-idx3-ubyte.gz"
train_labels_file = "MNIST_data/train-labels-idx1-ubyte.gz"
t10k_images_file = "MNIST_data/t10k-images-idx3-ubyte.gz"
t10k_labels_file = "MNIST_data/t10k-labels-idx1-ubyte.gz"
def read32(bytestream):
# 由于网络数据的编码是大端，所以需要加上>
dt = numpy.dtype(numpy.int32).newbyteorder('>')
data = bytestream.read(4)
return numpy.frombuffer(data, dt)[0]
def read_labels(filename):
with gzip.open(filename) as bytestream:
magic = read32(bytestream)
numberOfLabels = read32(bytestream)
labels = numpy.frombuffer(bytestream.read(numberOfLabels), numpy.uint8)
data = numpy.zeros((numberOfLabels, 10))
for i in xrange(len(labels)):
data[i][labels[i]] = 1
bytestream.close()
return data
def read_images(filename):
# 把文件解压成字节流
with gzip.open(filename) as bytestream:
magic = read32(bytestream)
numberOfImages = read32(bytestream)
rows = read32(bytestream)
columns = read32(bytestream)
images = numpy.frombuffer(bytestream.read(numberOfImages * rows * columns), numpy.uint8)
images.shape = (numberOfImages, rows * columns)
images = images.astype(numpy.float32)
images = numpy.multiply(images, 1.0 / 255.0)
bytestream.close()
return images
train_labels = read_labels(train_labels_file)
train_images = read_images(train_images_file)
test_labels = read_labels(t10k_labels_file)
test_images = read_images(t10k_images_file)
import tensorflow as tf
x = tf.placeholder("float", [None, 784.])
W = tf.Variable(tf.zeros([784., 10.]))
b = tf.Variable(tf.zeros([10.]))
y = tf.nn.softmax(tf.matmul(x, W) + b)
y_ = tf.placeholder("float")
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
for i in range(600):
batch_xs = train_images[100 * i:100 * i + 100]
batch_ys = train_labels[100 * i:100 * i + 100]
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
# 提高准确度，训练多一次
for i in range(600):
batch_xs = train_images[100 * i:100 * i + 100]
batch_ys = train_labels[100 * i:100 * i + 100]
sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print sess.run(accuracy, feed_dict={x: test_images, y_: test_labels})
Благодаря тестированию точность составляет около
0.9041, время: 2,4 секунды