diff --git a/python/paddle/fluid/dygraph/nn.py b/python/paddle/fluid/dygraph/nn.py
index afebf277d0d216f761224f2fb5325ae21cae2c56..f6009912bee9062a4a8478237a41c9168af50782 100644
--- a/python/paddle/fluid/dygraph/nn.py
+++ b/python/paddle/fluid/dygraph/nn.py
@@ -320,82 +320,3 @@ class BatchNorm(layers.Layer):
 
             # Currently, we don't support inplace in dygraph mode
             return self._helper.append_activation(batch_norm_out, self._act)
-
-
-class RowConv(layers.Layer):
-    """
-    ***Row-convolution operator***
-
-    The row convolution is called lookahead convolution.  This operator was introduced in the following paper for DeepSpeech2:
-    http://www.cs.cmu.edu/~dyogatam/papers/wang+etal.iclrworkshop2016.pdf
-
-    The main motivation is that a bidirectional RNN, useful in DeepSpeech like speech models, learns representation for a sequence by performing a
-    forward and a backward pass through the entire sequence. However, unlike
-    unidirectional RNNs, bidirectional RNNs are challenging to deploy in an online
-    and low-latency setting. The lookahead convolution incorporates information
-    from future subsequences in a computationally efficient manner to improve
-    unidirectional recurrent neural networks. The row convolution operator is
-    different from the 1D sequence convolution, and is computed as follows:
-
-    Given an input sequence X of length t and input dimension D, and a filter (W) of size context * D.
-
-    More details about row_conv please refer to the design document https://github.com/PaddlePaddle/Paddle/issues/2228#issuecomment-303903645 .
-
-    Parameters:
-        name_scope(str): The name of this class.
-        future_context_size (int): Future context size. Please note, the shape
-            of convolution kernel is [future_context_size + 1, D].
-        param_attr (ParamAttr): Attributes of parameters, including
-            name, initializer etc. Default: None.
-        act (str): Non-linear activation to be applied to output variable. Default: None.
-
-    Attributes:
-        weight (Parameter): the learnable weights of this layer.
-
-    Returns:
-        the output(Out) is a LodTensor, which supports variable time-length input sequences.
-        The underlying tensor in this LodTensor is a matrix with shape T x N, i.e., the same shape as X.
-
-    Examples:
-        .. code-block:: python
-
-          import paddle.fluid as fluid
-          import numpy
-
-          with fluid.dygraph.guard():
-              x = numpy.random.random((16)).astype('float32')
-              rowConv = fluid.dygraph.nn.RowConv(
-                    'RowConv', future_context_size=2)
-              ret = rowConv(fluid.dygraph.base.to_variable(x))
-
-    """
-
-    def __init__(
-        self, name_scope, future_context_size, param_attr=None, act=None
-    ):
-        assert (
-            not in_dygraph_mode()
-        ), "RowConv is not supported by dynamic graph mode yet!"
-        super().__init__(name_scope)
-        self._act = act
-        self._param_attr = param_attr
-        self._future_context_size = future_context_size
-
-    def _build_once(self, input):
-        self._dtype = self._helper.input_dtype(input)
-        filter_shape = [self._future_context_size + 1, input.shape[1]]
-        self.weight = self.create_parameter(
-            attr=self._param_attr,
-            shape=filter_shape,
-            dtype=self._dtype,
-            is_bias=False,
-        )
-
-    def forward(self, input):
-        out = self._helper.create_variable_for_type_inference(self._dtype)
-        self._helper.append_op(
-            type='row_conv',
-            inputs={'X': [input], 'Filter': [self.weight]},
-            outputs={'Out': [out]},
-        )
-        return self._helper.append_activation(out, act=self._act)