In [7]:

    

import numpy as np
import tensorflow as tf
import tensorflow.contrib.slim as slim
from six.moves import cPickle as pickle
from six.moves import range
import matplotlib.pyplot as plt


    

    





ImportErrorTraceback (most recent call last)
<ipython-input-7-be893e84687a> in <module>()
      2 import tensorflow as tf
      3 import tensorflow.contrib.slim as slim
----> 4 from inception.slim import ops
      5 from six.moves import cPickle as pickle
      6 from six.moves import range

ImportError: No module named 'inception'

In [2]:

    

pickle_file = 'notMNIST.pickle'

with open(pickle_file, 'rb') as f:
  save = pickle.load(f)
  train_dataset = save['train_dataset']
  train_labels = save['train_labels']
  valid_dataset = save['valid_dataset']
  valid_labels = save['valid_labels']
  test_dataset = save['test_dataset']
  test_labels = save['test_labels']
  del save  # hint to help gc free up memory
  print('Training set', train_dataset.shape, train_labels.shape)
  print('Validation set', valid_dataset.shape, valid_labels.shape)
  print('Test set', test_dataset.shape, test_labels.shape)


    

    




Training set (200000, 28, 28) (200000,)
Validation set (10000, 28, 28) (10000,)
Test set (10000, 28, 28) (10000,)

In [3]:

    

image_size = 28
num_labels = 10
num_channels = 1 # grayscale

import numpy as np

def reformat(dataset, labels):
  dataset = dataset.reshape((-1, image_size, image_size, num_channels)).astype(np.float32)
  # Map 1 to [0.0, 1.0, 0.0 ...], 2 to [0.0, 0.0, 1.0 ...]
  labels = (np.arange(num_labels) == labels[:,None]).astype(np.float32)
  return dataset, labels

train_dataset, train_labels = reformat(train_dataset, train_labels)
valid_dataset, valid_labels = reformat(valid_dataset, valid_labels)
test_dataset, test_labels = reformat(test_dataset, test_labels)

print('Training set', train_dataset.shape, train_labels.shape)
print('Validation set', valid_dataset.shape, valid_labels.shape)
print('Test set', test_dataset.shape, test_labels.shape)


    

    




Training set (200000, 28, 28, 1) (200000, 10)
Validation set (10000, 28, 28, 1) (10000, 10)
Test set (10000, 28, 28, 1) (10000, 10)

In [4]:

    

def accuracy(predictions, labels):
  return (100.0 * np.sum(np.argmax(predictions, 1) == np.argmax(labels, 1))
          / predictions.shape[0])


    

In [1]:

    

def model(images, is_training=False):
  # Create a small network.
  net = slim.conv2d(images, 16, [3, 3], stride=2, scope='conv1')
  net = slim.conv2d(net, 16, [3, 3], scope='conv2')
#  net = slim.ops.conv2d(net, 128, [3, 3], scope='conv3')
  net = slim.max_pool2d(net, [3, 3], stride=2, scope='pool3')
  net = slim.flatten(net)
  net = slim.fully_connected(net, 10, scope='logits')
  net = tf.nn.softmax(net)
  return net


    

In [ ]:

    

train_log_dir = 'slim-test'

if not tf.gfile.Exists(train_log_dir):
  tf.gfile.MakeDirs(train_log_dir)

with tf.Graph().as_default():
  # Set up the data loading:
  images, labels = train_dataset, tf.convert_to_tensor(train_labels)

  # Define the model:
  train_prediction = model(images, is_training=True)

  # Specify the loss function:
  slim.losses.softmax_cross_entropy(train_prediction, labels)

  total_loss = slim.losses.get_total_loss()
  tf.summary.scalar('losses/total_loss', total_loss)

  # Specify the optimization scheme:
  optimizer = tf.train.GradientDescentOptimizer(learning_rate=.001)

  # create_train_op that ensures that when we evaluate it to get the loss,
  # the update_ops are done and the gradient updates are computed.
  train_tensor = slim.learning.create_train_op(total_loss, optimizer)

  # Actually runs training.
  slim.learning.train(train_tensor, train_log_dir)


    

    




INFO:tensorflow:Starting Session.
INFO:tensorflow:Starting Queues.
INFO:tensorflow:global_step/sec: 0

In [ ]: