Commit f1c514a8 authored by ppwwyyxx's avatar ppwwyyxx

init

parent cbfadb31
*.gz
*.txt
# Byte-compiled / optimized / DLL files # Byte-compiled / optimized / DLL files
__pycache__/ __pycache__/
*.py[cod] *.py[cod]
......
# !/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)
#!/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)
# !/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)
#!/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()
#!/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()
# !/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)
#!/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
#!/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
# !/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)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment