直接保存mnist数据，供tensorflow使用

Halcom

直接保存mnist数据，供tensorflow使用：
（1）基类DataSet需要添加；
（2）mnist = pickle.load(pickle_data)
具体代码如下：

1. # -*- coding: utf-8 -*-
   
2. """
   
3. Created on Mon Aug 28 21:16:13 2017
   
4. 
   
5. @author: Administrator
   
6. """
   
7. 
   
8. import time   
   
9. import pickle
   
10. #from PIL import Image
    
11. import numpy
    
12. #import os
    
13. from six.moves import xrange  # pylint: disable=redefined-builtin
    
14. import tensorflow as tf
    
15. from tensorflow.python.framework import dtypes
    
16. 
    
17. class DataSet(object):
    
18. 
    
19.   def __init__(self,
    
20.                images,
    
21.                labels,
    
22.                fake_data=False,
    
23.                one_hot=False,
    
24.                dtype=dtypes.float32,
    
25.                reshape=True):
    
26.     """Construct a DataSet.
    
27.     one_hot arg is used only if fake_data is true.  `dtype` can be either
    
28.     `uint8` to leave the input as `[0, 255]`, or `float32` to rescale into
    
29.     `[0, 1]`.
    
30.     """
    
31.     dtype = dtypes.as_dtype(dtype).base_dtype
    
32.     if dtype not in (dtypes.uint8, dtypes.float32):
    
33.       raise TypeError('Invalid image dtype %r, expected uint8 or float32' %
    
34.                       dtype)
    
35.     if fake_data:
    
36.       self._num_examples = 10000
    
37.       self.one_hot = one_hot
    
38.     else:
    
39.       assert images.shape[0] == labels.shape[0], (
    
40.           'images.shape: %s labels.shape: %s' % (images.shape, labels.shape))
    
41.       self._num_examples = images.shape[0]
    
42. 
    
43.       # Convert shape from [num examples, rows, columns, depth]
    
44.       # to [num examples, rows*columns] (assuming depth == 1)
    
45.       if reshape:
    
46.         assert images.shape[3] == 1
    
47.         images = images.reshape(images.shape[0],
    
48.                                 images.shape[1] * images.shape[2])
    
49.       if dtype == dtypes.float32:
    
50.         # Convert from [0, 255] -> [0.0, 1.0].
    
51.         images = images.astype(numpy.float32)
    
52.         images = numpy.multiply(images, 1.0 / 255.0)
    
53.     self._images = images
    
54.     self._labels = labels
    
55.     self._epochs_completed = 0
    
56.     self._index_in_epoch = 0
    
57. 
    
58.   @property
    
59.   def images(self):
    
60.     return self._images
    
61. 
    
62.   @property
    
63.   def labels(self):
    
64.     return self._labels
    
65. 
    
66.   @property
    
67.   def num_examples(self):
    
68.     return self._num_examples
    
69. 
    
70.   @property
    
71.   def epochs_completed(self):
    
72.     return self._epochs_completed
    
73. 
    
74.   def next_batch(self, batch_size, fake_data=False, shuffle=True):
    
75.     """Return the next `batch_size` examples from this data set."""
    
76.     if fake_data:
    
77.       fake_image = [1] * 784
    
78.       if self.one_hot:
    
79.         fake_label = [1] + [0] * 9
    
80.       else:
    
81.         fake_label = 0
    
82.       return [fake_image for _ in xrange(batch_size)], [
    
83.           fake_label for _ in xrange(batch_size)
    
84.       ]
    
85.     start = self._index_in_epoch
    
86.     # Shuffle for the first epoch
    
87.     if self._epochs_completed == 0 and start == 0 and shuffle:
    
88.       perm0 = numpy.arange(self._num_examples)
    
89.       numpy.random.shuffle(perm0)
    
90.       self._images = self.images[perm0]
    
91.       self._labels = self.labels[perm0]
    
92.     # Go to the next epoch
    
93.     if start + batch_size > self._num_examples:
    
94.       # Finished epoch
    
95.       self._epochs_completed += 1
    
96.       # Get the rest examples in this epoch
    
97.       rest_num_examples = self._num_examples - start
    
98.       images_rest_part = self._images[start:self._num_examples]
    
99.       labels_rest_part = self._labels[start:self._num_examples]
    
100.       # Shuffle the data
     
101.       if shuffle:
     
102.         perm = numpy.arange(self._num_examples)
     
103.         numpy.random.shuffle(perm)
     
104.         self._images = self.images[perm]
     
105.         self._labels = self.labels[perm]
     
106.       # Start next epoch
     
107.       start = 0
     
108.       self._index_in_epoch = batch_size - rest_num_examples
     
109.       end = self._index_in_epoch
     
110.       images_new_part = self._images[start:end]
     
111.       labels_new_part = self._labels[start:end]
     
112.       return numpy.concatenate((images_rest_part, images_new_part), axis=0) , numpy.concatenate((labels_rest_part, labels_new_part), axis=0)
     
113.     else:
     
114.       self._index_in_epoch += batch_size
     
115.       end = self._index_in_epoch
     
116.       #print(start, end)
     
117.       return self._images[start:end], self._labels[start:end]
     
118. 
     
119. 
     
120. start=time.clock()
     
121. 
     
122. # 加载数据
     
123. pickle_data = open('mnist.pkl','rb');
     
124. mnist = pickle.load(pickle_data)
     
125. pickle_data.close()
     
126. 
     
127. end=time.clock()  
     
128. print('Runing time = %s Seconds'%(end-start))
     
129. 
     
130. # Create the model
     
131. x = tf.placeholder(tf.float32, [None, 784])
     
132. W = tf.Variable(tf.zeros([784, 10]))
     
133. b = tf.Variable(tf.zeros([10]))
     
134. y = tf.matmul(x, W) + b
     
135. 
     
136. # Define loss and optimizer
     
137. y_ = tf.placeholder(tf.float32, [None, 10])
     
138. 
     
139. 
     
140. cross_entropy = tf.reduce_mean(
     
141.       tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
     
142. train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
     
143. 
     
144. sess = tf.InteractiveSession()
     
145. tf.global_variables_initializer().run()
     
146. 
     
147. # Train
     
148. for _ in range(1000):
     
149.     batch_xs, batch_ys = mnist.train.next_batch(100)
     
150.     sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
     
151. 
     
152. # Test trained model
     
153. correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
     
154. accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
     
155. print(sess.run(accuracy, feed_dict={x: mnist.test.images,
     
156.                                       y_: mnist.test.labels}))
     

复制代码