def run_learn(pixels, label): cnn_dir = os.environ['VIRTUAL_ENV'] + "/mnist_convnet_model" mnist_dataset = mnist.load_mnist(train_dir=os.environ['VIRTUAL_ENV'] + '/MNIST-data') train_data = concat(mnist_dataset.train.images, pixels) train_labels = concat(mnist_dataset.train.labels, label) eval_data = concat(mnist_dataset.test.images, pixels) eval_labels = concat(mnist_dataset.test.labels, label) estimator = learn.Estimator(model_fn=cnn_model_fn, model_dir=cnn_dir) dataset_classifier = learn.SKCompat(estimator) tensors_to_log = {"probabilities": "softmax_tensor"} logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=500) dataset_classifier.fit(x=train_data, y=train_labels, batch_size=128, steps=5000, monitors=[logging_hook]) metrics = { "accuracy": learn.MetricSpec(metric_fn=tf.metrics.accuracy, prediction_key="classes") } eval_results = dataset_classifier.score(x=eval_data, y=eval_labels, metrics=metrics) return eval_results
def mnist(layers, activation="sigmoid", batch_size=128, mode="train"): """Mnist classification with a multi-layer perceptron.""" if activation == "sigmoid": activation_op = tf.sigmoid elif activation == "relu": activation_op = tf.nn.relu else: raise ValueError("{} activation not supported".format(activation)) # Data. data = mnist_dataset.load_mnist() data = getattr(data, mode) images = tf.constant(data.images, dtype=tf.float32, name="MNIST_images") images = tf.reshape(images, [-1, 28, 28, 1]) labels = tf.constant(data.labels, dtype=tf.int64, name="MNIST_labels") # Network. mlp = snt.nets.MLP(list(layers) + [10], activation=activation_op, initializers=_nn_initializers) network = snt.Sequential([snt.BatchFlatten(), mlp]) def build(): indices = tf.random_uniform([batch_size], 0, data.num_examples, tf.int64) batch_images = tf.gather(images, indices) batch_labels = tf.gather(labels, indices) output = network(batch_images) return _xent_loss(output, batch_labels) return build
def mnist(train=True): data = mnist_dataset.load_mnist() mode = "train" if train else "test" data = getattr(data, mode) imgs = data.images imgs = np.reshape(imgs, newshape=[-1, 28, 28, 1]) labels = data.labels return Dataset(imgs.astype("float32"), labels.astype("int32"))
def mnist_conv(batch_norm=True, batch_size=128, mode="train"): # Data. data = mnist_dataset.load_mnist() data = getattr(data, mode) images = tf.constant(data.images, dtype=tf.float32, name="MNIST_images") images = tf.reshape(images, [-1, 28, 28, 1]) labels = tf.constant(data.labels, dtype=tf.int64, name="MNIST_labels") def network(inputs, training=True): def _conv_activation(x): return tf.nn.max_pool(tf.nn.relu(x), ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID") def conv_layer(inputs, strides, c_h, c_w, output_channels, padding, name): n_channels = int(inputs.get_shape()[-1]) with tf.variable_scope(name) as scope: kernel1 = tf.get_variable('weights1', shape=[c_h, c_w, n_channels, output_channels], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01) ) biases1 = tf.get_variable('biases1', [output_channels], initializer=tf.constant_initializer(0.0)) inputs = tf.nn.conv2d(inputs, kernel1, [1, strides, strides, 1], padding) inputs = tf.nn.bias_add(inputs, biases1) if batch_norm: inputs = tf.layers.batch_normalization(inputs, training=training) inputs = _conv_activation(inputs) return inputs inputs = conv_layer(inputs, 1, 3, 3, 16, "VALID", 'conv_layer1') inputs = conv_layer(inputs, 1, 5, 5, 32, "VALID", 'conv_layer2') inputs = tf.reshape(inputs, [batch_size, -1]) fc_shape2 = int(inputs.get_shape()[1]) weights = tf.get_variable("fc_weights", shape=[fc_shape2, 10], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) bias = tf.get_variable("fc_bias", shape=[10, ], dtype=tf.float32, initializer=tf.constant_initializer(0.0)) return tf.nn.relu(tf.nn.bias_add(tf.matmul(inputs, weights), bias)) def build(): indices = tf.random_uniform([batch_size], 0, data.num_examples, tf.int64) batch_images = tf.gather(images, indices) batch_labels = tf.gather(labels, indices) output = network(batch_images) return _xent_loss(output, batch_labels) return build
def mnist(layers, # pylint: disable=invalid-name activation="relu", batch_size=128, mode="train"): """Mnist classification with a multi-layer perceptron.""" if activation == "sigmoid": activation_op = tf.sigmoid elif activation == "relu": activation_op = tf.nn.relu else: raise ValueError("{} activation not supported".format(activation)) # Data. proxy1 = 'http://proxy:8080' proxy2 = 'https://proxy:8080' os.environ['http_proxy'] = proxy1 os.environ['HTTP_PROXY'] = proxy1 os.environ['https_proxy'] = proxy2 os.environ['HTTPS_PROXY'] = proxy2 data = mnist_dataset.load_mnist() data = getattr(data, mode) images = tf.constant(data.images, dtype=tf.float32, name="MNIST_images") images = tf.reshape(images, [-1, 28, 28, 1]) labels = tf.constant(data.labels, dtype=tf.int64, name="MNIST_labels") # Network. mlp = snt.nets.MLP(list(layers) + [10], activation=activation_op, initializers=_nn_initializers) network = snt.Sequential([snt.BatchFlatten(), mlp]) def build(): indices = tf.random_uniform([batch_size], 0, data.num_examples, tf.int64) batch_images = tf.gather(images, indices) batch_labels = tf.gather(labels, indices) output = network(batch_images) return _xent_loss(output, batch_labels) def convex_loss(): v = tf.get_variable("v", shape=[1, 10], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) # Non-trainable variables. target = tf.get_variable("target", shape=[1, 10], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01), trainable=False) return tf.reduce_mean(tf.clip_by_value(tf.square(v - target), 0, 10)) return collections.OrderedDict([('Opt_loss', build), ('Aux_loss', convex_loss)])
def get_mnist(images_shape=get_input_shape_ones(), mode="train"): """ Returns the details about MNIST dataset, the reshaped images and the labels Args: images_shape: shape of the images mode: select iamges for training or testing Returns: A tuple where the first element contains meta informarmation about the dataset, the second element contains the images and the third element contains the labels """ data = mnist_dataset.load_mnist() data = getattr(data, mode) images = np.reshape(data.images, images_shape) labels = to_categorical(data.labels, FLAGS.num_classes) return data, images, labels
# min_after_dequeue is the minimum number elements in the queue # after a dequeue, which ensures sufficient mixing of elements. min_after_dequeue = 3000 # If `enqueue_many` is `False`, `tensors` is assumed to represent a # single example. An input tensor with shape `[x, y, z]` will be output # as a tensor with shape `[batch_size, x, y, z]`. # # If `enqueue_many` is `True`, `tensors` is assumed to represent a # batch of examples, where the first dimension is indexed by example, # and all members of `tensors` should have the same size in the # first dimension. If an input tensor has shape `[*, x, y, z]`, the # output will have shape `[batch_size, x, y, z]`. enqueue_many = True data = mnist.load_mnist() x_train_batch, y_train_batch = tf.train.shuffle_batch( tensors=[data.train.images, data.train.labels.astype(np.int32)], batch_size=batch_size, capacity=capacity, min_after_dequeue=min_after_dequeue, enqueue_many=enqueue_many, num_threads=8) x_train_batch = tf.cast(x_train_batch, tf.float32) x_train_batch = tf.reshape(x_train_batch, shape=batch_shape) y_train_batch = tf.cast(y_train_batch, tf.int32) y_train_batch = tf.one_hot(y_train_batch, classes) x_batch_shape = x_train_batch.get_shape().as_list()
def main(): # user options batch_size = 128 val_in_train = False # not sure how the validation part works during fit. use_model_checkpt = False # demo processing sess = tf.Session() KB.set_session(sess) gdev_list = get_available_gpus() ngpus = len(gdev_list) batch_size = batch_size * ngpus data = mnist.load_mnist() X_train = data.train.images # X_test = data.test.images train_samples = X_train.shape[0] # 60000 # test_samples = X_test.shape[0] # 10000 height_nrows = 28 width_ncols = 28 batch_shape = [batch_size, height_nrows, width_ncols, 1] epochs = 5 steps_per_epoch = train_samples / batch_size # validations_steps = test_samples / batch_size nclasses = 10 # The capacity variable controls the maximum queue size # allowed when prefetching data for training. capacity = 10000 # min_after_dequeue is the minimum number elements in the queue # after a dequeue, which ensures sufficient mixing of elements. min_after_dequeue = 3000 # If `enqueue_many` is `False`, `tensors` is assumed to represent a # single example. An input tensor with shape `[x, y, z]` will be output # as a tensor with shape `[batch_size, x, y, z]`. # # If `enqueue_many` is `True`, `tensors` is assumed to represent a # batch of examples, where the first dimension is indexed by example, # and all members of `tensors` should have the same size in the # first dimension. If an input tensor has shape `[*, x, y, z]`, the # output will have shape `[batch_size, x, y, z]`. enqueue_many = True x_train_batch, y_train_batch = tf.train.shuffle_batch( tensors=[data.train.images, data.train.labels.astype(np.int32)], batch_size=batch_size, capacity=capacity, min_after_dequeue=min_after_dequeue, enqueue_many=enqueue_many, num_threads=8) x_train_batch = tf.cast(x_train_batch, tf.float32) x_train_batch = tf.reshape(x_train_batch, shape=batch_shape) y_train_batch = tf.cast(y_train_batch, tf.int32) y_train_batch = tf.one_hot(y_train_batch, nclasses) x_train_input = Input(tensor=x_train_batch) # x_test_batch, y_test_batch = tf.train.batch( # tensors=[data.test.images, data.test.labels.astype(np.int32)], # batch_size=batch_size, # capacity=capacity, # enqueue_many=enqueue_many, # num_threads=8) # I like the non-functional definition of model more. # model_init = make_model(x_train_input, nclasses) # x_train_out = model_init.output # train_model = Model(inputs=[x_train_input], outputs=[x_train_out]) x_train_out = cnn_layers(x_train_input, nclasses) train_model = Model(inputs=[x_train_input], outputs=[x_train_out]) if ngpus > 1: train_model = make_parallel(train_model, gdev_list) lr = 2e-3 * ngpus train_model.compile(optimizer=RMSprop(lr=lr, decay=1e-5), loss='categorical_crossentropy', metrics=['accuracy'], target_tensors=[y_train_batch]) if ngpus > 1: print_mgpu_modelsummary(train_model) else: train_model.summary() # Callbacks if use_model_checkpt: mon = 'val_acc' if val_in_train else 'acc' checkpoint = ModelCheckpoint('saved_wt.h5', monitor=mon, verbose=0, save_best_only=True, save_weights_only=True) checkpoint = [checkpoint] else: checkpoint = [] callbacks = checkpoint # Training slower with callback. Multigpu slower with callback during # training than 1 GPU. Again, mnist is too trivial of a model and dataset # to benchmark or stress GPU compute capabilities. I set up this example # to illustrate potential for speedup of multigpu case trying to use mnist # as a stressor. # It's like comparing a 5 ft race between a person and a truck. A truck is # obviously faster than a person but in a 5 ft race the person will likely # win due to slower startup for the truck. # I will re-implement this with Cifar that should be a better benchmark. # Start the queue runners. tf.train.start_queue_runners(sess=sess) # Fit the model using data from the TFRecord data tensors. coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess, coord) start_time = time.time() train_model.fit( # validation_data=(x_test_batch, y_test_batch) # if val_in_train else None, # validation data is not used??? # validations_steps if val_in_train else None, # validation_steps=val_in_train, steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks) elapsed_time = time.time() - start_time print('[{}] finished in {} ms'.format('TRAINING', int(elapsed_time * 1000))) if not checkpoint: # empty list train_model.save_weights('./saved_wt.h5') # Clean up the TF session. coord.request_stop() coord.join(threads) KB.clear_session() # Second Session. Demonstrate that the model works and is independent of # the TFRecord pipeline, and to test loading trained model without tensors. x_test = np.reshape(data.validation.images, (data.validation.images.shape[0], 28, 28, 1)) y_test = data.validation.labels x_test_inp = KL.Input(shape=(x_test.shape[1:])) test_out = cnn_layers(x_test_inp, nclasses) test_model = Model(inputs=x_test_inp, outputs=test_out) test_model.load_weights('saved_wt.h5') test_model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) test_model.summary() loss, acc = test_model.evaluate(x_test, to_categorical(y_test)) print('\nTest loss: {0}'.format(loss)) print('\nTest accuracy: {0}'.format(acc))
correct = True for m in must: if m is None: correct = False break #Modify message here if correct is False: sys.exit( "Usage : python " + sys.argv[0] + " --alg <HMM algorithm> --num_hmms <Number of HMMs> --num_states <Number of states in each HMM> --frac_vertical <Number of HMMs to look at column information> --batch_size <mini-batch size> --num_epochs <Number of epochs to do training> [--init_file <optional file to initialize from> --saver_prefix [prefix of file in which session is saved]]" ) #Prepare datasets datasets = mnist.load_mnist() training_vectors = datasets[0].images training_labels = datasets[0].labels training_vectors = training_vectors.reshape( (training_vectors.shape[0], 28, 28)) training_vectors = np.array([v.T for v in training_vectors], dtype=np.float64) training_labels = one_hot(training_labels) test_vectors = datasets[2].images test_labels = datasets[2].labels test_vectors = np.array([v.T for v in test_vectors], dtype=np.float64) test_labels = one_hot(test_labels) Net = HMM.HMM_NN(num_dims=28, num_states=num_states, num_hmms=num_hmms) #Train if num_epochs != 0: Net.run_batch(training_vectors,
def __init__(self, args): args['var_count'] = 4 self.full = args['full'] super(Mnist, self).__init__(args=args) self.conv = False if 'conv' not in args else args['conv'] def get_data(data, mode='train'): mode_data = getattr(data, mode) images = tf.constant(mode_data.images, dtype=tf.float32, name="MNIST_images_" + mode) if self.conv: images = tf.reshape(images, [-1, 28, 28, 1]) if self.allow_gradients_of_gradients: labels = tf.one_hot(mode_data.labels, 10, name="MNIST_labels_" + mode) else: labels = tf.constant(mode_data.labels, dtype=tf.int64, name="MNIST_labels_" + mode) return images, labels data = mnist_dataset.load_mnist() self.training_data, self.test_data, self.validation_data = dict( ), dict(), dict() self.training_data['images'], self.training_data['labels'] = get_data( data, 'train') self.test_data['images'], self.test_data['labels'] = get_data( data, 'test') self.validation_data['images'], self.validation_data[ 'labels'] = get_data(data, 'validation') with tf.variable_scope(self.variable_scope): with tf.variable_scope('network_variables'): if self.conv: if self.full: filters = 32 f1 = 1024 else: filters = 16 f1 = 512 self.create_variable('w_1', dims=[5, 5, 1, filters]) self.create_variable('b_1', dims=[filters]) self.create_variable('w_2', dims=[5, 5, filters, filters * 2]) self.create_variable('b_2', dims=[filters * 2]) self.create_variable('w_3', dims=[7 * 7 * filters * 2, f1]) self.create_variable('b_3', dims=[f1]) self.create_variable('w_out', dims=[f1, 10]) self.create_variable('b_out', dims=[10]) else: if self.full: f1 = 40 else: f1 = 20 self.create_variable( 'w_1', dims=[ self.training_data['images'].get_shape()[1].value, f1 ]) self.create_variable('b_1', dims=[1, f1]) # self.create_variable('w_2', dims=[20, 20]) # self.create_variable('b_2', dims=[20]) # # self.create_variable('w_3', dims=[20, 20]) # self.create_variable('b_3', dims=[20]) self.create_variable('w_out', dims=[f1, 10]) self.create_variable('b_out', dims=[1, 10]) self.weight_norm_loss = 0 for variable in self.variables: self.weight_norm_loss += tf.nn.l2_loss(variable) self.end_init()
#!/usr/bin/env python #coding=utf-8 import core from tensorflow.contrib.learn.python.learn.datasets.mnist import load_mnist load_mnist() x_data = core.np.float32(core.np.random.rand(2, 100)) y_data = core.np.dot([0.100, 0.200], x_data) + 0.300 b = core.tf.Variable(core.tf.zeros([1])) w = core.tf.Variable(core.tf.random_uniform([1, 2], -1.0, 1.0)) y = core.tf.matmul(w, x_data) + b loss = core.tf.reduce_mean(core.tf.square(y - y_data)) optimazer = core.tf.train.GradientDescentOptimizer(0.5) train = optimazer.minimize(loss) init = core.tf.initialize_all_variables() sess = core.tf.Session() sess.run(init) for step in range(0, 201): sess.run(train) if step % 20 == 0: print(step, sess.run(w), sess.run(b))
def main(): # user options batch_size = 128 val_in_train = False # not sure how the validation part works during fit. use_model_checkpt = False # demo processing sess = tf.Session() KB.set_session(sess) gdev_list = get_available_gpus() ngpus = len(gdev_list) batch_size = batch_size * ngpus data = mnist.load_mnist() X_train = data.train.images # X_test = data.test.images train_samples = X_train.shape[0] # 60000 # test_samples = X_test.shape[0] # 10000 height_nrows = 28 width_ncols = 28 batch_shape = [batch_size, height_nrows, width_ncols, 1] epochs = 5 steps_per_epoch = train_samples // batch_size # validations_steps = test_samples / batch_size nclasses = 10 # The capacity variable controls the maximum queue size # allowed when prefetching data for training. capacity = 10000 # min_after_dequeue is the minimum number elements in the queue # after a dequeue, which ensures sufficient mixing of elements. min_after_dequeue = 3000 # If `enqueue_many` is `False`, `tensors` is assumed to represent a # single example. An input tensor with shape `[x, y, z]` will be output # as a tensor with shape `[batch_size, x, y, z]`. # # If `enqueue_many` is `True`, `tensors` is assumed to represent a # batch of examples, where the first dimension is indexed by example, # and all members of `tensors` should have the same size in the # first dimension. If an input tensor has shape `[*, x, y, z]`, the # output will have shape `[batch_size, x, y, z]`. enqueue_many = True x_train_batch, y_train_batch = tf.train.shuffle_batch( tensors=[data.train.images, data.train.labels.astype(np.int32)], batch_size=batch_size, capacity=capacity, min_after_dequeue=min_after_dequeue, enqueue_many=enqueue_many, num_threads=8) x_train_batch = tf.cast(x_train_batch, tf.float32) x_train_batch = tf.reshape(x_train_batch, shape=batch_shape) y_train_batch = tf.cast(y_train_batch, tf.int32) y_train_batch = tf.one_hot(y_train_batch, nclasses) x_train_input = Input(tensor=x_train_batch) # x_test_batch, y_test_batch = tf.train.batch( # tensors=[data.test.images, data.test.labels.astype(np.int32)], # batch_size=batch_size, # capacity=capacity, # enqueue_many=enqueue_many, # num_threads=8) # I like the non-functional definition of model more. # model_init = make_model(x_train_input, nclasses) # x_train_out = model_init.output # train_model = Model(inputs=[x_train_input], outputs=[x_train_out]) x_train_out = cnn_layers(x_train_input, nclasses) train_model = Model(inputs=[x_train_input], outputs=[x_train_out]) if ngpus > 1: train_model = make_parallel(train_model, gdev_list) lr = 2e-3 * ngpus train_model.compile(optimizer=RMSprop(lr=lr, decay=1e-5), loss='categorical_crossentropy', metrics=['accuracy'], target_tensors=[y_train_batch]) if ngpus > 1: print_mgpu_modelsummary(train_model) else: train_model.summary() # Callbacks if use_model_checkpt: mon = 'val_acc' if val_in_train else 'acc' checkpoint = ModelCheckpoint( 'saved_wt.h5', monitor=mon, verbose=0, save_best_only=True, save_weights_only=True) checkpoint = [checkpoint] else: checkpoint = [] callbacks = checkpoint # Training slower with callback. Multigpu slower with callback during # training than 1 GPU. Again, mnist is too trivial of a model and dataset # to benchmark or stress GPU compute capabilities. I set up this example # to illustrate potential for speedup of multigpu case trying to use mnist # as a stressor. # It's like comparing a 5 ft race between a person and a truck. A truck is # obviously faster than a person but in a 5 ft race the person will likely # win due to slower startup for the truck. # I will re-implement this with Cifar that should be a better benchmark. # Start the queue runners. tf.train.start_queue_runners(sess=sess) # Fit the model using data from the TFRecord data tensors. coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(sess, coord) start_time = time.time() train_model.fit( # validation_data=(x_test_batch, y_test_batch) # if val_in_train else None, # validation data is not used??? # validations_steps if val_in_train else None, # validation_steps=val_in_train, steps_per_epoch=steps_per_epoch, epochs=epochs, callbacks=callbacks) elapsed_time = time.time() - start_time print('[{}] finished in {} s'.format('TRAINING', round(elapsed_time, 3))) if not checkpoint: # empty list train_model.save_weights('./saved_wt.h5') # Clean up the TF session. coord.request_stop() coord.join(threads) KB.clear_session() # Second Session. Demonstrate that the model works and is independent of # the TFRecord pipeline, and to test loading trained model without tensors. x_test = np.reshape(data.validation.images, (data.validation.images.shape[0], 28, 28, 1)) y_test = data.validation.labels x_test_inp = KL.Input(shape=(x_test.shape[1:])) test_out = cnn_layers(x_test_inp, nclasses) test_model = Model(inputs=x_test_inp, outputs=test_out) test_model.load_weights('saved_wt.h5') test_model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy']) test_model.summary() loss, acc = test_model.evaluate(x_test, to_categorical(y_test)) print('\nTest loss: {0}'.format(loss)) print('\nTest accuracy: {0}'.format(acc))
def mnist_conv( activation="relu", # pylint: disable=invalid-name batch_norm=True, batch_size=128, mode="train"): """Mnist classification with a multi-layer perceptron.""" if activation == "sigmoid": activation_op = tf.sigmoid elif activation == "relu": activation_op = tf.nn.relu else: raise ValueError("{} activation not supported".format(activation)) # Data. data = mnist_dataset.load_mnist() data = getattr(data, mode) images = tf.constant(data.images, dtype=tf.float32, name="MNIST_images") images = tf.reshape(images, [-1, 28, 28, 1]) labels = tf.constant(data.labels, dtype=tf.int64, name="MNIST_labels") if mode == 'train': is_training = True elif mode == 'test': is_training = False # Network. # mlp = snt.nets.MLP(list(layers) + [10], # activation=activation_op, # initializers=_nn_initializers) # network = snt.Sequential([snt.BatchFlatten(), mlp]) def network(inputs, training=is_training): # pdb.set_trace() def _conv_activation(x): # pylint: disable=invalid-name return tf.nn.max_pool(tf.nn.relu(x), ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID") def conv_layer(inputs, strides, c_h, c_w, output_channels, padding, name): n_channels = int(inputs.get_shape()[-1]) with tf.variable_scope(name) as scope: kernel1 = tf.get_variable( 'weights1', shape=[c_h, c_w, n_channels, output_channels], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) biases1 = tf.get_variable( 'biases1', [output_channels], initializer=tf.constant_initializer(0.0)) inputs = tf.nn.conv2d(inputs, kernel1, [1, strides, strides, 1], padding) inputs = tf.nn.bias_add(inputs, biases1) if batch_norm: inputs = tf.layers.batch_normalization(inputs, training=training) inputs = _conv_activation(inputs) return inputs if batch_norm: linear_activation = lambda x: tf.nn.relu( tf.layers.batch_normalization(x, training=training)) else: linear_activation = tf.nn.relu # pdb.set_trace() # print(inputs.shape) inputs = conv_layer(inputs, 1, 3, 3, 16, "VALID", 'conv_layer1') # print(inputs.shape) inputs = conv_layer(inputs, 1, 5, 5, 32, "VALID", 'conv_layer2') # print(inputs.shape) # inputs = linear_activation(inputs) inputs = tf.reshape(inputs, [batch_size, -1]) # print(inputs.shape) fc_shape1 = int(inputs.get_shape()[0]) fc_shape2 = int(inputs.get_shape()[1]) weights = tf.get_variable( "fc_weights", shape=[fc_shape2, 10], dtype=tf.float32, initializer=tf.random_normal_initializer(stddev=0.01)) # print(weights.shape) bias = tf.get_variable("fc_bias", shape=[ 10, ], dtype=tf.float32, initializer=tf.constant_initializer(0.0)) # print(bias.shape) return tf.nn.relu(tf.nn.bias_add(tf.matmul(inputs, weights), bias)) def build(): indices = tf.random_uniform([batch_size], 0, data.num_examples, tf.int64) batch_images = tf.gather(images, indices) batch_labels = tf.gather(labels, indices) output = network(batch_images) return _xent_loss(output, batch_labels) return build