Skip to content

Instantly share code, notes, and snippets.

What would you like to do?
TensorFlow Variable-Length Sequence Classification (Updated)
# Updated to work with TF 1.4
# Working example for my blog post at:
import functools
import sets
import tensorflow as tf
from tensorflow import nn
def lazy_property(function):
attribute = '_' + function.__name__
def wrapper(self):
if not hasattr(self, attribute):
setattr(self, attribute, function(self))
return getattr(self, attribute)
return wrapper
class VariableSequenceClassification:
def __init__(self, data, target, num_hidden=200, num_layers=2): = data = target
self._num_hidden = num_hidden
self._num_layers = num_layers
def length(self):
used = tf.sign(tf.reduce_max(tf.abs(, reduction_indices=2))
length = tf.reduce_sum(used, reduction_indices=1)
length = tf.cast(length, tf.int32)
return length
def prediction(self):
# Recurrent network.
output, _ = nn.dynamic_rnn(
last = self._last_relevant(output, self.length)
# Softmax layer.
weight, bias = self._weight_and_bias(
self._num_hidden, int([1]))
prediction = tf.nn.softmax(tf.matmul(last, weight) + bias)
return prediction
def cost(self):
cross_entropy = -tf.reduce_sum( * tf.log(self.prediction))
return cross_entropy
def optimize(self):
learning_rate = 0.003
optimizer = tf.train.RMSPropOptimizer(learning_rate)
return optimizer.minimize(self.cost)
def error(self):
mistakes = tf.not_equal(
tf.argmax(, 1), tf.argmax(self.prediction, 1))
return tf.reduce_mean(tf.cast(mistakes, tf.float32))
def _weight_and_bias(in_size, out_size):
weight = tf.truncated_normal([in_size, out_size], stddev=0.01)
bias = tf.constant(0.1, shape=[out_size])
return tf.Variable(weight), tf.Variable(bias)
def _last_relevant(output, length):
batch_size = tf.shape(output)[0]
max_length = int(output.get_shape()[1])
output_size = int(output.get_shape()[2])
index = tf.range(0, batch_size) * max_length + (length - 1)
flat = tf.reshape(output, [-1, output_size])
relevant = tf.gather(flat, index)
return relevant
if __name__ == '__main__':
# We treat images as sequences of pixel rows.
train, test = sets.Mnist()
_, rows, row_size =
num_classes =[1]
data = tf.placeholder(tf.float32, [None, rows, row_size])
target = tf.placeholder(tf.float32, [None, num_classes])
model = VariableSequenceClassification(data, target)
sess = tf.Session()
for epoch in range(10):
for _ in range(100):
batch = train.sample(10), {data:, target:})
error =, {data:, target:})
print('Epoch {:2d} error {:3.1f}%'.format(epoch + 1, 100 * error))

This comment has been minimized.

Copy link

seyedrezamirkhani commented Nov 23, 2018

Thanks for making this example work with TF 1.4

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.