prompt: We are currently solving the following issue within our repository. Here is the issue text:
  --- BEGIN ISSUE ---
  Document about initializers
  Criteria for initializer arguments of links is complicated (https://github.com/chainer/chainer/pull/3259#issuecomment-325562538). We should write some dedicated documentation about that, and let each link documentation point to it. Maybe we can write on [this page](https://docs.chainer.org/en/v2.0.2/reference/initializers.html).
  
  Also we should describe *the default initializer* (which is `LeCunNormal`).
  
  --- END ISSUE ---
  
  Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
  --- BEGIN FILES ---
  Path: `chainer/links/connection/linear.py`
  Content:
  ```
  1 from chainer.functions.connection import linear
  2 from chainer import initializers
  3 from chainer import link
  4 from chainer import variable
  5 
  6 
  7 class Linear(link.Link):
  8 
  9     """Linear layer (a.k.a.\\  fully-connected layer).
  10 
  11     This is a link that wraps the :func:`~chainer.functions.linear` function,
  12     and holds a weight matrix ``W`` and optionally a bias vector ``b`` as
  13     parameters.
  14 
  15     The weight matrix ``W`` is initialized with i.i.d. Gaussian samples, each
  16     of which has zero mean and deviation :math:`\\sqrt{1/\\text{in_size}}`. The
  17     bias vector ``b`` is of size ``out_size``. Each element is initialized with
  18     the ``bias`` value. If ``nobias`` argument is set to ``True``, then this
  19     link does not hold a bias vector.
  20 
  21     Args:
  22         in_size (int or None): Dimension of input vectors. If ``None``,
  23             parameter initialization will be deferred until the first forward
  24             data pass at which time the size will be determined.
  25         out_size (int): Dimension of output vectors.
  26         nobias (bool): If ``True``, then this function does not use the bias.
  27         initialW (2-D array): Initial weight value. If ``None``, then the
  28             default initializer is used.
  29             May also be a callable that takes ``numpy.ndarray`` or
  30             ``cupy.ndarray`` and edits its value.
  31         initial_bias (1-D array): Initial bias value. If ``None``, the bias
  32             vector is initialized to zero.
  33             May also be a callable that takes ``numpy.ndarray`` or
  34             ``cupy.ndarray`` and edits its value.
  35     .. seealso:: :func:`~chainer.functions.linear`
  36 
  37     Attributes:
  38         W (~chainer.Variable): Weight parameter.
  39         b (~chainer.Variable): Bias parameter.
  40 
  41     .. admonition:: Example
  42 
  43         There are several ways to make a Linear link.
  44 
  45         Define an input vector ``x`` as:
  46 
  47         >>> x = np.array([[0, 1, 2, 3, 4]], 'f')
  48 
  49         1. Give the first two arguments explicitly:
  50 
  51             Those numbers are considered as the input size and the output size.
  52 
  53             >>> l = L.Linear(5, 10)
  54             >>> y = l(x)
  55             >>> y.shape
  56             (1, 10)
  57 
  58         2. Omit ``in_size`` (give the output size only as the first argument)
  59            or fill it with ``None``:
  60 
  61             In this case, the size of second axis of ``x`` is used as the
  62             input size. So the below two cases are the same.
  63 
  64             >>> l = L.Linear(10)
  65             >>> y = l(x)
  66             >>> y.shape
  67             (1, 10)
  68 
  69             >>> l = L.Linear(None, 10)
  70             >>> y = l(x)
  71             >>> y.shape
  72             (1, 10)
  73 
  74             When you omit the first argument, you need to specify the other
  75             subsequent arguments from ``nobias`` as keyword arguments. So the
  76             below two cases are the same.
  77 
  78             >>> l = L.Linear(None, 10, False, None, 0)
  79             >>> y = l(x)
  80             >>> y.shape
  81             (1, 10)
  82 
  83             >>> l = L.Linear(10, nobias=False, initialW=None, initial_bias=0)
  84             >>> y = l(x)
  85             >>> y.shape
  86             (1, 10)
  87 
  88     """
  89 
  90     def __init__(self, in_size, out_size=None, nobias=False,
  91                  initialW=None, initial_bias=None):
  92         super(Linear, self).__init__()
  93 
  94         if out_size is None:
  95             in_size, out_size = None, in_size
  96         self.out_size = out_size
  97 
  98         with self.init_scope():
  99             W_initializer = initializers._get_initializer(initialW)
  100             self.W = variable.Parameter(W_initializer)
  101             if in_size is not None:
  102                 self._initialize_params(in_size)
  103 
  104             if nobias:
  105                 self.b = None
  106             else:
  107                 if initial_bias is None:
  108                     initial_bias = 0
  109                 bias_initializer = initializers._get_initializer(initial_bias)
  110                 self.b = variable.Parameter(bias_initializer, out_size)
  111 
  112     def _initialize_params(self, in_size):
  113         self.W.initialize((self.out_size, in_size))
  114 
  115     def __call__(self, x):
  116         """Applies the linear layer.
  117 
  118         Args:
  119             x (~chainer.Variable): Batch of input vectors.
  120 
  121         Returns:
  122             ~chainer.Variable: Output of the linear layer.
  123 
  124         """
  125         if self.W.data is None:
  126             self._initialize_params(x.size // x.shape[0])
  127         return linear.linear(x, self.W, self.b)
  128
  ```
  --- END FILES ---
  
  Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.
  
  Here is an example:
  
  ```diff
  diff --git a/examples/server_async.py b/examples/server_async.py
  --- a/examples/server_async.py
  +++ b/examples/server_async.py
  @@ -313,4 +313,4 @@
   
   
   if __name__ == "__main__":
  -    asyncio.run(run_async_server("."), debug=True)
  +    asyncio.run(run_async_server(), debug=True)
  diff --git a/examples/server_sync.py b/examples/server_sync.py
  --- a/examples/server_sync.py
  +++ b/examples/server_sync.py
  @@ -313,5 +313,5 @@
   
   
   if __name__ == "__main__":
  -    server = run_sync_server(".")
  +    server = run_sync_server()
       server.shutdown()
  
  ```
  
golden_diff: diff --git a/chainer/links/connection/linear.py b/chainer/links/connection/linear.py
  --- a/chainer/links/connection/linear.py
  +++ b/chainer/links/connection/linear.py
  @@ -24,14 +24,11 @@
               data pass at which time the size will be determined.
           out_size (int): Dimension of output vectors.
           nobias (bool): If ``True``, then this function does not use the bias.
  -        initialW (2-D array): Initial weight value. If ``None``, then the
  -            default initializer is used.
  -            May also be a callable that takes ``numpy.ndarray`` or
  -            ``cupy.ndarray`` and edits its value.
  -        initial_bias (1-D array): Initial bias value. If ``None``, the bias
  -            vector is initialized to zero.
  -            May also be a callable that takes ``numpy.ndarray`` or
  -            ``cupy.ndarray`` and edits its value.
  +        initialW (:ref:`initializer <initializer>`): Initializer to initialize
  +            the weight.
  +        initial_bias (:ref:`initializer <initializer>`): Initializer to
  +            initialize the bias. If ``None``, the bias will be initialized to
  +            zero.
       .. seealso:: :func:`~chainer.functions.linear`
   
       Attributes:
  
verification_info: {"golden_diff": "diff --git a/chainer/links/connection/linear.py b/chainer/links/connection/linear.py\n--- a/chainer/links/connection/linear.py\n+++ b/chainer/links/connection/linear.py\n@@ -24,14 +24,11 @@\n             data pass at which time the size will be determined.\n         out_size (int): Dimension of output vectors.\n         nobias (bool): If ``True``, then this function does not use the bias.\n-        initialW (2-D array): Initial weight value. If ``None``, then the\n-            default initializer is used.\n-            May also be a callable that takes ``numpy.ndarray`` or\n-            ``cupy.ndarray`` and edits its value.\n-        initial_bias (1-D array): Initial bias value. If ``None``, the bias\n-            vector is initialized to zero.\n-            May also be a callable that takes ``numpy.ndarray`` or\n-            ``cupy.ndarray`` and edits its value.\n+        initialW (:ref:`initializer <initializer>`): Initializer to initialize\n+            the weight.\n+        initial_bias (:ref:`initializer <initializer>`): Initializer to\n+            initialize the bias. If ``None``, the bias will be initialized to\n+            zero.\n     .. seealso:: :func:`~chainer.functions.linear`\n \n     Attributes:\n", "issue": "Document about initializers\nCriteria for initializer arguments of links is complicated (https://github.com/chainer/chainer/pull/3259#issuecomment-325562538). We should write some dedicated documentation about that, and let each link documentation point to it. Maybe we can write on [this page](https://docs.chainer.org/en/v2.0.2/reference/initializers.html).\r\n\r\nAlso we should describe *the default initializer* (which is `LeCunNormal`).\n", "before_files": [{"content": "from chainer.functions.connection import linear\nfrom chainer import initializers\nfrom chainer import link\nfrom chainer import variable\n\n\nclass Linear(link.Link):\n\n    \"\"\"Linear layer (a.k.a.\\\\  fully-connected layer).\n\n    This is a link that wraps the :func:`~chainer.functions.linear` function,\n    and holds a weight matrix ``W`` and optionally a bias vector ``b`` as\n    parameters.\n\n    The weight matrix ``W`` is initialized with i.i.d. Gaussian samples, each\n    of which has zero mean and deviation :math:`\\\\sqrt{1/\\\\text{in_size}}`. The\n    bias vector ``b`` is of size ``out_size``. Each element is initialized with\n    the ``bias`` value. If ``nobias`` argument is set to ``True``, then this\n    link does not hold a bias vector.\n\n    Args:\n        in_size (int or None): Dimension of input vectors. If ``None``,\n            parameter initialization will be deferred until the first forward\n            data pass at which time the size will be determined.\n        out_size (int): Dimension of output vectors.\n        nobias (bool): If ``True``, then this function does not use the bias.\n        initialW (2-D array): Initial weight value. If ``None``, then the\n            default initializer is used.\n            May also be a callable that takes ``numpy.ndarray`` or\n            ``cupy.ndarray`` and edits its value.\n        initial_bias (1-D array): Initial bias value. If ``None``, the bias\n            vector is initialized to zero.\n            May also be a callable that takes ``numpy.ndarray`` or\n            ``cupy.ndarray`` and edits its value.\n    .. seealso:: :func:`~chainer.functions.linear`\n\n    Attributes:\n        W (~chainer.Variable): Weight parameter.\n        b (~chainer.Variable): Bias parameter.\n\n    .. admonition:: Example\n\n        There are several ways to make a Linear link.\n\n        Define an input vector ``x`` as:\n\n        >>> x = np.array([[0, 1, 2, 3, 4]], 'f')\n\n        1. Give the first two arguments explicitly:\n\n            Those numbers are considered as the input size and the output size.\n\n            >>> l = L.Linear(5, 10)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n        2. Omit ``in_size`` (give the output size only as the first argument)\n           or fill it with ``None``:\n\n            In this case, the size of second axis of ``x`` is used as the\n            input size. So the below two cases are the same.\n\n            >>> l = L.Linear(10)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n            >>> l = L.Linear(None, 10)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n            When you omit the first argument, you need to specify the other\n            subsequent arguments from ``nobias`` as keyword arguments. So the\n            below two cases are the same.\n\n            >>> l = L.Linear(None, 10, False, None, 0)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n            >>> l = L.Linear(10, nobias=False, initialW=None, initial_bias=0)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n    \"\"\"\n\n    def __init__(self, in_size, out_size=None, nobias=False,\n                 initialW=None, initial_bias=None):\n        super(Linear, self).__init__()\n\n        if out_size is None:\n            in_size, out_size = None, in_size\n        self.out_size = out_size\n\n        with self.init_scope():\n            W_initializer = initializers._get_initializer(initialW)\n            self.W = variable.Parameter(W_initializer)\n            if in_size is not None:\n                self._initialize_params(in_size)\n\n            if nobias:\n                self.b = None\n            else:\n                if initial_bias is None:\n                    initial_bias = 0\n                bias_initializer = initializers._get_initializer(initial_bias)\n                self.b = variable.Parameter(bias_initializer, out_size)\n\n    def _initialize_params(self, in_size):\n        self.W.initialize((self.out_size, in_size))\n\n    def __call__(self, x):\n        \"\"\"Applies the linear layer.\n\n        Args:\n            x (~chainer.Variable): Batch of input vectors.\n\n        Returns:\n            ~chainer.Variable: Output of the linear layer.\n\n        \"\"\"\n        if self.W.data is None:\n            self._initialize_params(x.size // x.shape[0])\n        return linear.linear(x, self.W, self.b)\n", "path": "chainer/links/connection/linear.py"}], "after_files": [{"content": "from chainer.functions.connection import linear\nfrom chainer import initializers\nfrom chainer import link\nfrom chainer import variable\n\n\nclass Linear(link.Link):\n\n    \"\"\"Linear layer (a.k.a.\\\\  fully-connected layer).\n\n    This is a link that wraps the :func:`~chainer.functions.linear` function,\n    and holds a weight matrix ``W`` and optionally a bias vector ``b`` as\n    parameters.\n\n    The weight matrix ``W`` is initialized with i.i.d. Gaussian samples, each\n    of which has zero mean and deviation :math:`\\\\sqrt{1/\\\\text{in_size}}`. The\n    bias vector ``b`` is of size ``out_size``. Each element is initialized with\n    the ``bias`` value. If ``nobias`` argument is set to ``True``, then this\n    link does not hold a bias vector.\n\n    Args:\n        in_size (int or None): Dimension of input vectors. If ``None``,\n            parameter initialization will be deferred until the first forward\n            data pass at which time the size will be determined.\n        out_size (int): Dimension of output vectors.\n        nobias (bool): If ``True``, then this function does not use the bias.\n        initialW (:ref:`initializer <initializer>`): Initializer to initialize\n            the weight.\n        initial_bias (:ref:`initializer <initializer>`): Initializer to\n            initialize the bias. If ``None``, the bias will be initialized to\n            zero.\n    .. seealso:: :func:`~chainer.functions.linear`\n\n    Attributes:\n        W (~chainer.Variable): Weight parameter.\n        b (~chainer.Variable): Bias parameter.\n\n    .. admonition:: Example\n\n        There are several ways to make a Linear link.\n\n        Define an input vector ``x`` as:\n\n        >>> x = np.array([[0, 1, 2, 3, 4]], 'f')\n\n        1. Give the first two arguments explicitly:\n\n            Those numbers are considered as the input size and the output size.\n\n            >>> l = L.Linear(5, 10)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n        2. Omit ``in_size`` (give the output size only as the first argument)\n           or fill it with ``None``:\n\n            In this case, the size of second axis of ``x`` is used as the\n            input size. So the below two cases are the same.\n\n            >>> l = L.Linear(10)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n            >>> l = L.Linear(None, 10)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n            When you omit the first argument, you need to specify the other\n            subsequent arguments from ``nobias`` as keyword arguments. So the\n            below two cases are the same.\n\n            >>> l = L.Linear(None, 10, False, None, 0)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n            >>> l = L.Linear(10, nobias=False, initialW=None, initial_bias=0)\n            >>> y = l(x)\n            >>> y.shape\n            (1, 10)\n\n    \"\"\"\n\n    def __init__(self, in_size, out_size=None, nobias=False,\n                 initialW=None, initial_bias=None):\n        super(Linear, self).__init__()\n\n        if out_size is None:\n            in_size, out_size = None, in_size\n        self.out_size = out_size\n\n        with self.init_scope():\n            W_initializer = initializers._get_initializer(initialW)\n            self.W = variable.Parameter(W_initializer)\n            if in_size is not None:\n                self._initialize_params(in_size)\n\n            if nobias:\n                self.b = None\n            else:\n                if initial_bias is None:\n                    initial_bias = 0\n                bias_initializer = initializers._get_initializer(initial_bias)\n                self.b = variable.Parameter(bias_initializer, out_size)\n\n    def _initialize_params(self, in_size):\n        self.W.initialize((self.out_size, in_size))\n\n    def __call__(self, x):\n        \"\"\"Applies the linear layer.\n\n        Args:\n            x (~chainer.Variable): Batch of input vectors.\n\n        Returns:\n            ~chainer.Variable: Output of the linear layer.\n\n        \"\"\"\n        if self.W.data is None:\n            self._initialize_params(x.size // x.shape[0])\n        return linear.linear(x, self.W, self.b)\n", "path": "chainer/links/connection/linear.py"}]}