rnn_cell.linear and models.rnn are going away.

Instead of rnn_cell.linear, use tf.contrib.layers.linear (though keep in mind the weight initializer is different; to avoid a bias term use bias_init=None).

tf.models.rnn and tf.models.rnn_cell had been kept around for backwards compatibility.  importing them now raises ImportError pointing to tf.nn.rnn*.
Change: 122064919

tensorflow/models/rnn/README.md

@@ -11,11 +11,3 @@ File | What's in it?
 --- | ---
 `ptb/` | PTB language model, see the [RNN Tutorial](http://tensorflow.org/tutorials/recurrent/)
 `translate/` | Translation model, see the [Sequence-to-Sequence Tutorial](http://tensorflow.org/tutorials/seq2seq/)
-`linear.py` | Basic helper functions for creating linear layers (moved to tf.nn, deprecated in favor of layers).
-`linear_test.py` | Unit tests for `linear.py` (moved into TF core).
-`rnn_cell.py` | Cells for recurrent neural networks, e.g., LSTM (moved to tf.nn.rnn_cell).
-`rnn_cell_test.py` | Unit tests for `rnn_cell.py` (moved into TF core).
-`rnn.py` | Functions for building recurrent neural networks (functions moved into in tf.nn).
-`rnn_test.py` | Unit tests for `rnn.py` (moved into TF core).
-`seq2seq.py` | Functions for building sequence-to-sequence models (moved to tf.nn.seq2seq).
-`seq2seq_test.py` | Unit tests for `seq2seq.py` (moved into TF core).

tensorflow/models/rnn/__init__.py

@@ -17,7 +17,3 @@
 from __future__ import absolute_import
 from __future__ import division
 from __future__ import print_function
-
-from tensorflow.models.rnn import rnn
-from tensorflow.models.rnn import rnn_cell
-from tensorflow.models.rnn import seq2seq

tensorflow/models/rnn/linear.py

@@ -17,6 +17,4 @@
 from __future__ import division
 from __future__ import print_function
 
-import tensorflow as tf
-
-linear = tf.nn.linear
+raise ImportError("This module is deprecated.  Use tf.contrib.layers.linear.")

tensorflow/models/rnn/ptb/BUILD

@@ -45,9 +45,6 @@ py_binary(
     deps = [
         ":reader",
         "//tensorflow:tensorflow_py",
-        "//tensorflow/models/rnn",
-        "//tensorflow/models/rnn:rnn_cell",
-        "//tensorflow/models/rnn:seq2seq",
     ],
 )
 

tensorflow/models/rnn/rnn.py

@@ -18,5 +18,4 @@
 from __future__ import division
 from __future__ import print_function
 
-# pylint: disable=wildcard-import
-from tensorflow.python.ops.rnn import *
+raise ImportError("This module is deprecated.  Use tf.nn.rnn_* instead.")

tensorflow/models/rnn/rnn_cell.py

@@ -18,5 +18,4 @@
 from __future__ import division
 from __future__ import print_function
 
-# pylint: disable=wildcard-import
-from tensorflow.python.ops.rnn_cell import *
+raise ImportError("This module is deprecated.  Use tf.nn.rnn_cell instead.")

tensorflow/models/rnn/seq2seq.py

@@ -18,5 +18,4 @@
 from __future__ import division
 from __future__ import print_function
 
-# pylint: disable=wildcard-import
-from tensorflow.python.ops.seq2seq import *
+raise ImportError("This module is deprecated.  Use tf.nn.seq2seq instead.")

tensorflow/models/rnn/translate/BUILD

@@ -37,7 +37,6 @@ py_library(
     deps = [
         ":data_utils",
         "//tensorflow:tensorflow_py",
-        "//tensorflow/models/rnn:seq2seq",
     ],
 )
 

tensorflow/python/kernel_tests/rnn_cell_test.py

@@ -23,27 +23,32 @@
 import numpy as np
 import tensorflow as tf
 
+# TODO(ebrevdo): Remove once _linear is fully deprecated.
+# pylint: disable=protected-access
+from tensorflow.python.ops.rnn_cell import _linear as linear
+# pylint: enable=protected-access
+
 
 class RNNCellTest(tf.test.TestCase):
 
   def testLinear(self):
     with self.test_session() as sess:
       with tf.variable_scope("root", initializer=tf.constant_initializer(1.0)):
         x = tf.zeros([1, 2])
-        l = tf.nn.rnn_cell.linear([x], 2, False)
+        l = linear([x], 2, False)
         sess.run([tf.initialize_all_variables()])
         res = sess.run([l], {x.name: np.array([[1., 2.]])})
         self.assertAllClose(res[0], [[3.0, 3.0]])
 
         # Checks prevent you from accidentally creating a shared function.
         with self.assertRaises(ValueError):
-          l1 = tf.nn.rnn_cell.linear([x], 2, False)
+          l1 = linear([x], 2, False)
 
         # But you can create a new one in a new scope and share the variables.
         with tf.variable_scope("l1") as new_scope:
-          l1 = tf.nn.rnn_cell.linear([x], 2, False)
+          l1 = linear([x], 2, False)
         with tf.variable_scope(new_scope, reuse=True):
-          tf.nn.rnn_cell.linear([l1], 2, False)
+          linear([l1], 2, False)
         self.assertEqual(len(tf.trainable_variables()), 2)
 
   def testBasicRNNCell(self):
@@ -311,8 +316,8 @@ def basic_rnn_cell(inputs, state, num_units, scope=None):
     return init_output, init_state
   else:
     with tf.variable_op_scope([inputs, state], scope, "BasicRNNCell"):
-      output = tf.tanh(tf.nn.rnn_cell.linear([inputs, state],
-                                             num_units, True))
+      output = tf.tanh(linear([inputs, state],
+                              num_units, True))
     return output, output
 
 if __name__ == "__main__":

tensorflow/python/ops/rnn_cell.py

@@ -136,7 +136,7 @@ def output_size(self):
   def __call__(self, inputs, state, scope=None):
     """Most basic RNN: output = new_state = tanh(W * input + U * state + B)."""
     with vs.variable_scope(scope or type(self).__name__):  # "BasicRNNCell"
-      output = tanh(linear([inputs, state], self._num_units, True))
+      output = tanh(_linear([inputs, state], self._num_units, True))
     return output, output
 
 
@@ -161,11 +161,11 @@ def __call__(self, inputs, state, scope=None):
     with vs.variable_scope(scope or type(self).__name__):  # "GRUCell"
       with vs.variable_scope("Gates"):  # Reset gate and update gate.
         # We start with bias of 1.0 to not reset and not update.
-        r, u = array_ops.split(1, 2, linear([inputs, state],
-                                            2 * self._num_units, True, 1.0))
+        r, u = array_ops.split(1, 2, _linear([inputs, state],
+                                             2 * self._num_units, True, 1.0))
         r, u = sigmoid(r), sigmoid(u)
       with vs.variable_scope("Candidate"):
-        c = tanh(linear([inputs, r * state], self._num_units, True))
+        c = tanh(_linear([inputs, r * state], self._num_units, True))
       new_h = u * state + (1 - u) * c
     return new_h, new_h
 
@@ -223,7 +223,7 @@ def __call__(self, inputs, state, scope=None):
         c, h = state
       else:
         c, h = array_ops.split(1, 2, state)
-      concat = linear([inputs, h], 4 * self._num_units, True)
+      concat = _linear([inputs, h], 4 * self._num_units, True)
 
       # i = input_gate, j = new_input, f = forget_gate, o = output_gate
       i, j, f, o = array_ops.split(1, 4, concat)
@@ -485,7 +485,7 @@ def __call__(self, inputs, state, scope=None):
     output, res_state = self._cell(inputs, state)
     # Default scope: "OutputProjectionWrapper"
     with vs.variable_scope(scope or type(self).__name__):
-      projected = linear(output, self._output_size, True)
+      projected = _linear(output, self._output_size, True)
     return projected, res_state
 
 
@@ -527,7 +527,7 @@ def __call__(self, inputs, state, scope=None):
     """Run the input projection and then the cell."""
     # Default scope: "InputProjectionWrapper"
     with vs.variable_scope(scope or type(self).__name__):
-      projected = linear(inputs, self._num_proj, True)
+      projected = _linear(inputs, self._num_proj, True)
     return self._cell(projected, state)
 
 
@@ -751,7 +751,7 @@ def __call__(self, inputs, state, scope=None):
     return output, state
 
 
-def linear(args, output_size, bias, bias_start=0.0, scope=None):
+def _linear(args, output_size, bias, bias_start=0.0, scope=None):
   """Linear map: sum_i(args[i] * W[i]), where W[i] is a variable.
 
   Args:

tensorflow/python/ops/seq2seq.py

@@ -72,6 +72,9 @@
 from tensorflow.python.ops import rnn_cell
 from tensorflow.python.ops import variable_scope
 
+# TODO(ebrevdo): Remove once _linear is fully deprecated.
+linear = rnn_cell._linear  # pylint: disable=protected-access
+
 
 def _extract_argmax_and_embed(embedding, output_projection=None,
                               update_embedding=True):
@@ -522,7 +525,7 @@ def attention(query):
       ds = []  # Results of attention reads will be stored here.
       for a in xrange(num_heads):
         with variable_scope.variable_scope("Attention_%d" % a):
-          y = rnn_cell.linear(query, attention_vec_size, True)
+          y = linear(query, attention_vec_size, True)
           y = array_ops.reshape(y, [-1, 1, 1, attention_vec_size])
           # Attention mask is a softmax of v^T * tanh(...).
           s = math_ops.reduce_sum(
@@ -555,7 +558,7 @@ def attention(query):
       input_size = inp.get_shape().with_rank(2)[1]
       if input_size.value is None:
         raise ValueError("Could not infer input size from input: %s" % inp.name)
-      x = rnn_cell.linear([inp] + attns, input_size, True)
+      x = linear([inp] + attns, input_size, True)
       # Run the RNN.
       cell_output, state = cell(x, state)
       # Run the attention mechanism.
@@ -567,7 +570,7 @@ def attention(query):
         attns = attention(state)
 
       with variable_scope.variable_scope("AttnOutputProjection"):
-        output = rnn_cell.linear([cell_output] + attns, output_size, True)
+        output = linear([cell_output] + attns, output_size, True)
       if loop_function is not None:
         prev = output
       outputs.append(output)