init

.gitignore

+*.gz
+*.txt
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]

dataflow/__init__.py

+# !/usr/bin/env python2
+#  -*- coding: UTF-8 -*-
+#  File: __init__.py
+#  Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+from pkgutil import walk_packages
+import os
+import os.path
+
+def global_import(name):
+    p = __import__(name, globals(), locals())
+    lst = p.__all__ if '__all__' in dir(p) else dir(p)
+    for k in lst:
+        globals()[k] = p.__dict__[k]
+
+for _, module_name, _ in walk_packages(
+        [os.path.dirname(__file__)]):
+    if not module_name.startswith('_'):
+        global_import(module_name)
+

dataflow/batch.py

+#!/usr/bin/env python2
+# -*- coding: UTF-8 -*-
+# File: batch.py
+# Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+import numpy as np
+
+__all__ = ['BatchData']
+
+class BatchData(object):
+
+    def __init__(self, ds, batch_size):
+        self.ds = ds
+        self.batch_size = batch_size
+
+    def get_data(self):
+        holder = []
+        for data in self.ds.get_data():
+            holder.append(data)
+            if len(holder) == self.batch_size:
+                yield BatchData.aggregate_batch(holder)
+                holder = []
+
+    @staticmethod
+    def aggregate_batch(data_holder):
+        size = len(data_holder[0])
+        result = []
+        for k in xrange(size):
+            result.append(
+                np.array([x[k] for x in data_holder],
+                         dtype=data_holder[0][k].dtype))
+        return tuple(result)
+

dataflow/dataset/__init__.py

+# !/usr/bin/env python2
+#  -*- coding: UTF-8 -*-
+#  File: __init__.py
+#  Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+from pkgutil import walk_packages
+import os
+import os.path
+
+def global_import(name):
+    p = __import__(name, globals(), locals())
+    lst = p.__all__ if '__all__' in dir(p) else dir(p)
+    for k in lst:
+        globals()[k] = p.__dict__[k]
+
+for _, module_name, _ in walk_packages(
+        [os.path.dirname(__file__)]):
+    if not module_name.startswith('_'):
+        global_import(module_name)
+

dataflow/dataset/mnist.py

+#!/usr/bin/env python2
+# -*- coding: UTF-8 -*-
+# File: mnist.py
+# Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+
+import os
+from tensorflow.examples.tutorials.mnist import input_data
+
+__all__ = ['Mnist']
+
+class Mnist(object):
+    def __init__(self, train_or_test, dir=None):
+        """
+        Args:
+            train_or_test: string either 'train' or 'test'
+        """
+        if dir is None:
+            dir = os.path.join(os.path.dirname(__file__), 'mnist')
+        self.dataset = input_data.read_data_sets(dir)
+        self.train_or_test = train_or_test
+
+    def get_data(self):
+        ds = self.dataset.train if self.train_or_test == 'train' else self.dataset.test
+        for k in xrange(ds.num_examples):
+            img = ds.images[k]
+            label = ds.labels[k]
+            yield (img, label)
+
+if __name__ == '__main__':
+    ds = Mnist()
+    ds.get_data()

example_mnist.py

+#!/usr/bin/env python2
+# -*- coding: UTF-8 -*-
+# File: example_mnist.py
+# Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+import tensorflow as tf
+import numpy as np
+from layers import *
+from utils import *
+from dataflow.dataset import Mnist
+from dataflow import *
+
+IMAGE_SIZE = 28
+PIXELS = IMAGE_SIZE * IMAGE_SIZE
+NUM_CLASS = 10
+batch_size = 128
+LOG_DIR = 'train_log'
+
+def get_model(input, label):
+    """
+    Args:
+        input: bxPIXELS
+        label: bx1 integer
+    Returns:
+        (output, cost)
+        output: variable
+        cost: scalar variable
+    """
+    fc0 = FullyConnected('fc0', input, 200)
+    fc0 = tf.nn.relu(fc0)
+    fc1 = FullyConnected('fc1', fc0, out_dim=200)
+    fc1 = tf.nn.relu(fc1)
+    fc2 = FullyConnected('lr', fc1, out_dim=10)
+    prob = tf.nn.softmax(fc2)
+
+    logprob = tf.log(prob)
+    y = one_hot(label, NUM_CLASS)
+    cost = tf.reduce_sum(-y * logprob, 1)
+    cost = tf.reduce_mean(cost, name='cost')
+
+    tf.scalar_summary(cost.op.name, cost)
+    return prob, cost
+
+def get_eval(prob, labels):
+    """
+    Args:
+        prob: bx10
+        labels: b
+    Returns:
+        scalar float: accuracy
+    """
+    correct = tf.nn.in_top_k(prob, labels, 1)
+
+    nr_correct = tf.reduce_sum(tf.cast(correct, tf.int32))
+    return tf.cast(nr_correct, tf.float32) / tf.cast(tf.size(labels), tf.float32)
+
+def main():
+    dataset_train = BatchData(Mnist('train'), batch_size)
+    dataset_test = BatchData(Mnist('test'), batch_size)
+    with tf.Graph().as_default():
+        input_var = tf.placeholder(tf.float32, shape=(batch_size, PIXELS))
+        label_var = tf.placeholder(tf.int32, shape=(batch_size,))
+
+        prob, cost = get_model(input_var, label_var)
+
+        optimizer = tf.train.AdagradOptimizer(0.01)
+        train_op = optimizer.minimize(cost)
+
+        eval_op = get_eval(prob, label_var)
+        summary_op = tf.merge_all_summaries()
+        saver = tf.train.Saver()
+
+        sess = tf.Session()
+        init = tf.initialize_all_variables()
+        sess.run(init)
+        summary_writer = tf.train.SummaryWriter(LOG_DIR,
+                                                graph_def=sess.graph_def)
+
+        epoch = 0
+        while True:
+            epoch += 1
+            for (img, label) in dataset_train.get_data():
+                feed = {input_var: img,
+                        label_var: label}
+
+                _, cost_value = sess.run([train_op, cost], feed_dict=feed)
+
+            print('Epoch %d: cost = %.2f' % (epoch, cost_value))
+
+            summary_str = sess.run(summary_op, feed_dict=feed)
+            summary_writer.add_summary(summary_str, epoch)
+
+            if epoch % 2 == 0:
+                saver.save(sess, LOG_DIR, global_step=epoch)
+
+                scores = []
+                for (img, label) in dataset_test.get_data():
+                    feed = {input_var: img, label_var: label}
+                    scores.append(sess.run(eval_op, feed_dict=feed))
+                print "Test Scores: {}".format(np.array(scores).mean())
+
+
+
+if __name__ == '__main__':
+    main()

layers/__init__.py

+# !/usr/bin/env python2
+#  -*- coding: UTF-8 -*-
+#  File: __init__.py
+#  Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+from pkgutil import walk_packages
+import os
+import os.path
+
+def global_import(name):
+    p = __import__(name, globals(), locals())
+    lst = p.__all__ if '__all__' in dir(p) else dir(p)
+    for k in lst:
+        globals()[k] = p.__dict__[k]
+
+for _, module_name, _ in walk_packages(
+        [os.path.dirname(__file__)]):
+    if not module_name.startswith('_'):
+        global_import(module_name)
+

layers/_common.py

+#!/usr/bin/env python2
+# -*- coding: UTF-8 -*-
+# File: _common.py
+# Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+__all__ = ['layer_register']
+import tensorflow as tf
+
+def layer_register():
+    def wrapper(func):
+        def inner(*args, **kwargs):
+            name = args[0]
+            assert isinstance(name, basestring)
+            args = args[1:]
+
+            with tf.name_scope(name):
+                return func(*args, **kwargs)
+        return inner
+    return wrapper

layers/fc.py

+#!/usr/bin/env python2
+# -*- coding: UTF-8 -*-
+# File: fc.py
+# Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+
+from ._common import layer_register
+import tensorflow as tf
+import math
+
+__all__ = ['FullyConnected']
+
+@layer_register()
+def FullyConnected(x, out_dim, W_init=None, b_init=None):
+    """
+    x: matrix of bxn
+    """
+    in_dim = x.get_shape().as_list()[1]
+
+    if W_init is None:
+        W_init = lambda shape: tf.truncated_normal(
+            shape, stddev=1.0 / math.sqrt(float(in_dim)))
+    if b_init is None:
+        b_init = tf.zeros
+
+    W = tf.Variable(W_init([in_dim, out_dim]), name='W')
+    b = tf.Variable(b_init([out_dim]), name='b')
+    return tf.matmul(x, W) + b

utils/__init__.py

+# !/usr/bin/env python2
+#  -*- coding: UTF-8 -*-
+#  File: __init__.py
+#  Author: Yuxin Wu <ppwwyyxx@gmail.com>
+
+import tensorflow as tf
+
+
+def one_hot(y, num_labels):
+    batch_size = y.get_shape().as_list()[0]
+    assert type(batch_size) == int, type(batch_size)
+    y = tf.expand_dims(y, 1)
+    indices = tf.expand_dims(tf.range(0, batch_size), 1)
+    concated = tf.concat(1, [indices, y])
+    onehot_labels = tf.sparse_to_dense(
+        concated, tf.pack([batch_size, num_labels]), 1.0, 0.0)
+    onehot_labels.set_shape([batch_size, num_labels])
+    return tf.cast(onehot_labels, tf.float32)