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()

```

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:

{"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"}]}