Merge branch 'master' of github.com:google/skflow

Author: ilblackdragon

examples/README.md

@@ -24,7 +24,8 @@ Image classification
 Text classification
 -------------------
 
-* [Text Classification Using Recurrent Neural Networks on Words](text_classification.py) (See also [Simplified Version Using Built-in RNN Model](text_classification_builtin_rnn_model.py))
+* [Text Classification Using Recurrent Neural Networks on Words](text_classification.py) 
+(See also [Simplified Version Using Built-in RNN Model](text_classification_builtin_rnn_model.py) with easy to use built-in parameters)
 * [Text Classification Using Convolutional Neural Networks on Words](text_classification_cnn.py)
 * [Text Classification Using Recurrent Neural Networks on Characters](text_classification_character_rnn.py)
 * [Text Classification Using Convolutional Neural Networks on Characters](text_classification_character_cnn.py)

examples/resnet.py

@@ -15,6 +15,9 @@
 """
 This example builds deep residual network for mnist data. 
 Reference Paper: http://arxiv.org/pdf/1512.03385.pdf
+
+Note that this is still a work-in-progress. Feel free to submit a PR
+to make this better. 
 """
 
 import os
@@ -31,32 +34,30 @@
 
 
 def res_net(x, y, activation=tf.nn.relu):
-    """Builds a residual network.
+    """Builds a residual network. Note that if the input tensor is 2D, it must be
+    square in order to be converted to a 4D tensor. 
 
     Borrowed structure from here: https://github.com/pkmital/tensorflow_tutorials/blob/master/10_residual_network.py
 
     Args:
         x: Input of the network
         y: Output of the network
         activation: Activation function to apply after each convolution
-    Raises:
-        ValueError
-            If a 2D tensor is not square, it cannot be converted to a 
-            4D tensor.
     """
-    LayerBlock = namedtuple(
-        'LayerBlock', ['num_layers', 'num_filters', 'bottleneck_size'])
-    blocks = [LayerBlock(3, 128, 32),
-              LayerBlock(3, 256, 64),
-              LayerBlock(3, 512, 128),
-              LayerBlock(3, 1024, 256)]
-
-    # Input check
+
+    # Configurations for each bottleneck block
+    BottleneckBlock = namedtuple(
+        'BottleneckBlock', ['num_layers', 'num_filters', 'bottleneck_size'])
+    blocks = [BottleneckBlock(3, 128, 32),
+              BottleneckBlock(3, 256, 64),
+              BottleneckBlock(3, 512, 128),
+              BottleneckBlock(3, 1024, 256)]
+
     input_shape = x.get_shape().as_list()
+
+    # Reshape the input into the right shape if it's 2D tensor
     if len(input_shape) == 2:
         ndim = int(sqrt(input_shape[1]))
-        if ndim * ndim != input_shape[1]:
-            raise ValueError('input_shape should be square')
         x = tf.reshape(x, [-1, ndim, ndim, 1])
 
     # First convolution expands to 64 channels
@@ -74,11 +75,13 @@ def res_net(x, y, activation=tf.nn.relu):
                                [1, 1], [1, 1, 1, 1],
                                padding='VALID', bias=True)
 
-    # Create resnets for each residual block
+    # Create each bottleneck building block for each layer
     for block_i, block in enumerate(blocks):
         for layer_i in range(block.num_layers):
 
             name = 'block_%d/layer_%d' % (block_i, layer_i)
+
+            # 1x1 convolution responsible for reducing dimension
             with tf.variable_scope(name + '/conv_in'):
                 conv = skflow.ops.conv2d(net, block.num_filters,
                                          [1, 1], [1, 1, 1, 1],
@@ -95,6 +98,7 @@ def res_net(x, y, activation=tf.nn.relu):
                                          batch_norm=True,
                                          bias=False)
 
+            # 1x1 convolution responsible for restoring dimension
             with tf.variable_scope(name + '/conv_out'):
                 conv = skflow.ops.conv2d(conv, block.num_filters,
                                          [1, 1], [1, 1, 1, 1],
@@ -103,6 +107,8 @@ def res_net(x, y, activation=tf.nn.relu):
                                          batch_norm=True,
                                          bias=False)
 
+            # shortcut connections that turn the network into its counterpart
+            # residual function (identity shortcut)
             net = conv + net
 
         try:
@@ -116,16 +122,13 @@ def res_net(x, y, activation=tf.nn.relu):
         except IndexError:
             pass
 
-
+    net_shape = net.get_shape().as_list()
     net = tf.nn.avg_pool(net,
-                         ksize=[1, net.get_shape().as_list()[1],
-                                net.get_shape().as_list()[2], 1],
+                         ksize=[1, net_shape[1], net_shape[2], 1],
                          strides=[1, 1, 1, 1], padding='VALID')
-    net = tf.reshape(
-        net,
-        [-1, net.get_shape().as_list()[1] *
-         net.get_shape().as_list()[2] *
-         net.get_shape().as_list()[3]])
+
+    net_shape = net.get_shape().as_list()
+    net = tf.reshape(net, [-1, net_shape[1] * net_shape[2] * net_shape[3]])
 
     return skflow.models.logistic_regression(net, y)
 

skflow/tests/test_nonlinear.py

@@ -65,31 +65,40 @@ def testRNN(self):
                               [2, 2, 3, 4, 5],
                               [3, 3, 1, 2, 1],
                               [2, 4, 5, 4, 1]]), dtype=np.float32)
+        # labels for classification
         labels = np.array(list([1, 0, 1, 0]), dtype=np.float32)
+        # targets for regression
+        targets = np.array(list([10, 16, 10, 16]), dtype=np.float32)
+        test_data = np.array(list([[1, 3, 3, 2, 1], [2, 3, 4, 5, 6]]))
         def input_fn(X):
             return tf.split(1, 5, X)
 
         # Classification
         classifier = skflow.TensorFlowRNNClassifier(
             rnn_size=2, cell_type='lstm', n_classes=2, input_op_fn=input_fn)
         classifier.fit(data, labels)
-        predictions = classifier.predict(np.array(list([[1, 3, 3, 2, 1],
-                                                        [2, 3, 4, 5, 6]])))
+        classifier.weights_
+        classifier.bias_
+        predictions = classifier.predict(test_data)
         self.assertAllClose(predictions, np.array([1, 0]))
 
-        classifier = skflow.TensorFlowRNNClassifier(
-            rnn_size=2, cell_type='gru', n_classes=2, input_op_fn=input_fn)
         classifier = skflow.TensorFlowRNNClassifier(
             rnn_size=2, cell_type='rnn', n_classes=2,
             input_op_fn=input_fn, num_layers=2)
-
-        # Regression
-        classifier = skflow.TensorFlowRNNRegressor(
-            rnn_size=2, cell_type='lstm', input_op_fn=input_fn)
         classifier.fit(data, labels)
-        predictions = classifier.predict(np.array(list([[1, 3, 3, 2, 1],
-                                                        [2, 3, 4, 5, 6]])))
+        classifier = skflow.TensorFlowRNNClassifier(
+            rnn_size=2, cell_type='invalid_cell_type', n_classes=2,
+            input_op_fn=input_fn, num_layers=2)
+        with self.assertRaises(ValueError):
+            classifier.fit(data, labels)
 
+        # Regression
+        regressor = skflow.TensorFlowRNNRegressor(
+            rnn_size=2, cell_type='gru', input_op_fn=input_fn)
+        regressor.fit(data, targets)
+        regressor.weights_
+        regressor.bias_
+        predictions = regressor.predict(test_data)
 
 if __name__ == "__main__":
     tf.test.main()