We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
the default value for allow_inplace changed from False to True
This change was added in #392 

# Before

https://github.com/pmeier/pystiche/blob/950b84837df26a0cab2f9f2714884655173206bf/pystiche/enc/models/vgg.py#L149

https://github.com/pmeier/pystiche/blob/950b84837df26a0cab2f9f2714884655173206bf/pystiche/enc/models/alexnet.py#L38

# After

https://github.com/pmeier/pystiche/blob/3fd3504b94d6bce5389784abea9e91d23c5fb153/pystiche/enc/models/utils.py#L51

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `pystiche/enc/models/utils.py`
Content:
```
1 from abc import abstractmethod
2 from typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, cast
3 
4 import torch
5 from torch import hub, nn
6 from torch.nn.modules.module import _IncompatibleKeys
7 
8 from ..multi_layer_encoder import MultiLayerEncoder
9 from ..prepostprocessing import preprocessing
10 
11 __all__ = ["ModelMultiLayerEncoder", "select_url"]
12 
13 T = TypeVar("T")
14 
15 
16 def select_url(
17     urls: Dict[T, str], key: T, format: Optional[Callable[[T], str]] = None
18 ) -> str:
19     if format is None:
20         format = str
21 
22     try:
23         return urls[key]
24     except KeyError as error:
25         raise RuntimeError(f"No URL is available for\n\n{format(key)}") from error
26 
27 
28 class ModelMultiLayerEncoder(MultiLayerEncoder):
29     r"""Multi-layer encoder based on a pre-defined model.
30 
31     Args:
32         pretrained: If ``True``, loads builtin weights. Defaults to ``True``.
33         framework: Name of the framework that was used to train the builtin weights.
34             Defaults to ``"torch"``.
35         internal_preprocessing: If ``True``, adds a preprocessing layer for the
36             selected ``framework`` as first layer. Defaults to ``True``.
37         allow_inplace: If ``True``, allows inplace operations to reduce the memory
38             requirement during the forward pass. Defaults to ``False``.
39 
40             .. warning::
41                 After performing an inplace operation the encodings of the previous
42                 layer is no longer accessible. Only use this if you are sure that you
43                 do **not** need these encodings.
44     """
45 
46     def __init__(
47         self,
48         pretrained: bool = True,
49         framework: str = "torch",
50         internal_preprocessing: bool = True,
51         allow_inplace: bool = True,
52     ) -> None:
53         self.pretrained = pretrained
54         self.framework = framework
55         self.internal_preprocessing = internal_preprocessing
56         self.allow_inplace = allow_inplace
57 
58         modules, self._state_dict_key_map = self.collect_modules(allow_inplace)
59         if internal_preprocessing:
60             modules.insert(0, ("preprocessing", preprocessing(framework)))
61 
62         super().__init__(modules)
63 
64         if pretrained:
65             self.load_state_dict_from_url(framework)
66 
67     @abstractmethod
68     def state_dict_url(self, framework: str) -> str:
69         r"""Select URL of a downloadable ``state_dict``.
70 
71         Args:
72             framework: Name of the framework that was used to train the weights.
73 
74         Raises:
75             RuntimeError: If no ``state_dict`` is available.
76         """
77         pass
78 
79     @abstractmethod
80     def collect_modules(
81         self, inplace: bool
82     ) -> Tuple[List[Tuple[str, nn.Module]], Dict[str, str]]:
83         r"""Collect modules of a base model with more descriptive names.
84 
85         Args:
86             inplace: If ``True``, when possible, modules should use inplace operations.
87 
88         Returns:
89             List of name-module-pairs as well as a dictionary mapping the new, more
90             descriptive names to the original ones.
91         """
92         pass
93 
94     def _map_state_dict_keys(
95         self, state_dict: Dict[str, torch.Tensor]
96     ) -> Tuple[Dict[str, torch.Tensor], List[str]]:
97         remapped_state_dict = {}
98         unexpected_keys = []
99         for key, value in state_dict.items():
100             if key in self._state_dict_key_map:
101                 remapped_state_dict[self._state_dict_key_map[key]] = value
102             else:
103                 unexpected_keys.append(key)
104 
105         return remapped_state_dict, unexpected_keys
106 
107     def load_state_dict(
108         self,
109         state_dict: Dict[str, torch.Tensor],
110         strict: bool = True,
111         map_names: bool = True,
112         framework: str = "unknown",
113     ) -> _IncompatibleKeys:
114         r"""Loads parameters and buffers from the ``state_dict``.
115 
116         Args:
117             state_dict: State dictionary.
118             strict: Enforce matching keys in ``state_dict`` and the internal states.
119             map_names: If ``True``, maps the names names in ``state_dict`` of the
120                 underlying model to the more descriptive names generated by
121                 :meth:`collect_modules`. Defaults to ``True``.
122             framework: Name of the framework that was used to train the weights in
123                 ``state_dict``. Defaults to ``"unknown"``.
124 
125                 .. note::
126 
127                     This has no effect on the behavior, but makes the representation
128                     of the :class:`ModelMultiLayerEncoder` more descriptive.
129 
130         Returns:
131             Named tuple with ``missing_keys`` and ``unexpected_keys`` fields.
132 
133         .. seealso::
134 
135             :meth:`torch.nn.Module.load_state_dict`
136         """
137         if map_names:
138             state_dict, unexpected_keys = self._map_state_dict_keys(state_dict)
139         else:
140             unexpected_keys = []
141 
142         keys = cast(
143             _IncompatibleKeys, super().load_state_dict(state_dict, strict=strict)
144         )
145         keys.unexpected_keys.extend(unexpected_keys)
146 
147         self.pretrained = True
148         self.framework = framework
149 
150         return keys
151 
152     def load_state_dict_from_url(
153         self,
154         framework: str,
155         strict: bool = True,
156         map_names: bool = True,
157         check_hash: bool = True,
158         **kwargs: Any,
159     ) -> None:
160         r"""Downloads and loads parameters and buffers trained with ``framework``.
161 
162         Args:
163             framework: Name of the framework that was used to train the weights of the
164                 ``state_dict``.
165             strict: Enforce matching keys in ``state_dict`` and the internal states.
166             map_names: If ``True``, maps the names names in ``state_dict`` of the
167                 underlying model to the more descriptive names generated by
168                 :meth:`collect_modules`. Defaults to ``True``.
169             check_hash: If ``True``, checks if the hash postfix of the URL matches the
170                 SHA256 hash of the downloaded ``state_dict``. Defaults to ``True``.
171             kwargs: Optional arguments for :meth:`torch.hub.load_state_dict_from_url` .
172 
173         .. seealso::
174 
175             - :meth:`state_dict_url`
176             - :meth:`load_state_dict`
177             - :meth:`torch.hub.load_state_dict_from_url`
178         """
179         url = self.state_dict_url(framework)
180         state_dict = hub.load_state_dict_from_url(url, check_hash=check_hash, **kwargs)
181         self.load_state_dict(
182             state_dict, strict=strict, map_names=map_names, framework=framework
183         )
184 
185     def _properties(self) -> Dict[str, Any]:
186         dct = super()._properties()
187         if not self.pretrained:
188             dct["pretrained"] = False
189         else:
190             dct["framework"] = self.framework
191         if not self.internal_preprocessing:
192             dct["internal_preprocessing"] = self.internal_preprocessing
193         if self.allow_inplace:
194             dct["allow_inplace"] = self.allow_inplace
195         return dct
196
```
--- 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/pystiche/enc/models/utils.py b/pystiche/enc/models/utils.py
--- a/pystiche/enc/models/utils.py
+++ b/pystiche/enc/models/utils.py
@@ -48,7 +48,7 @@
         pretrained: bool = True,
         framework: str = "torch",
         internal_preprocessing: bool = True,
-        allow_inplace: bool = True,
+        allow_inplace: bool = False,
     ) -> None:
         self.pretrained = pretrained
         self.framework = framework

{"golden_diff": "diff --git a/pystiche/enc/models/utils.py b/pystiche/enc/models/utils.py\n--- a/pystiche/enc/models/utils.py\n+++ b/pystiche/enc/models/utils.py\n@@ -48,7 +48,7 @@\n         pretrained: bool = True,\n         framework: str = \"torch\",\n         internal_preprocessing: bool = True,\n-        allow_inplace: bool = True,\n+        allow_inplace: bool = False,\n     ) -> None:\n         self.pretrained = pretrained\n         self.framework = framework\n", "issue": "the default value for allow_inplace changed from False to True\nThis change was added in #392 \r\n\r\n# Before\r\n\r\nhttps://github.com/pmeier/pystiche/blob/950b84837df26a0cab2f9f2714884655173206bf/pystiche/enc/models/vgg.py#L149\r\n\r\nhttps://github.com/pmeier/pystiche/blob/950b84837df26a0cab2f9f2714884655173206bf/pystiche/enc/models/alexnet.py#L38\r\n\r\n# After\r\n\r\nhttps://github.com/pmeier/pystiche/blob/3fd3504b94d6bce5389784abea9e91d23c5fb153/pystiche/enc/models/utils.py#L51\n", "before_files": [{"content": "from abc import abstractmethod\nfrom typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, cast\n\nimport torch\nfrom torch import hub, nn\nfrom torch.nn.modules.module import _IncompatibleKeys\n\nfrom ..multi_layer_encoder import MultiLayerEncoder\nfrom ..prepostprocessing import preprocessing\n\n__all__ = [\"ModelMultiLayerEncoder\", \"select_url\"]\n\nT = TypeVar(\"T\")\n\n\ndef select_url(\n    urls: Dict[T, str], key: T, format: Optional[Callable[[T], str]] = None\n) -> str:\n    if format is None:\n        format = str\n\n    try:\n        return urls[key]\n    except KeyError as error:\n        raise RuntimeError(f\"No URL is available for\\n\\n{format(key)}\") from error\n\n\nclass ModelMultiLayerEncoder(MultiLayerEncoder):\n    r\"\"\"Multi-layer encoder based on a pre-defined model.\n\n    Args:\n        pretrained: If ``True``, loads builtin weights. Defaults to ``True``.\n        framework: Name of the framework that was used to train the builtin weights.\n            Defaults to ``\"torch\"``.\n        internal_preprocessing: If ``True``, adds a preprocessing layer for the\n            selected ``framework`` as first layer. Defaults to ``True``.\n        allow_inplace: If ``True``, allows inplace operations to reduce the memory\n            requirement during the forward pass. Defaults to ``False``.\n\n            .. warning::\n                After performing an inplace operation the encodings of the previous\n                layer is no longer accessible. Only use this if you are sure that you\n                do **not** need these encodings.\n    \"\"\"\n\n    def __init__(\n        self,\n        pretrained: bool = True,\n        framework: str = \"torch\",\n        internal_preprocessing: bool = True,\n        allow_inplace: bool = True,\n    ) -> None:\n        self.pretrained = pretrained\n        self.framework = framework\n        self.internal_preprocessing = internal_preprocessing\n        self.allow_inplace = allow_inplace\n\n        modules, self._state_dict_key_map = self.collect_modules(allow_inplace)\n        if internal_preprocessing:\n            modules.insert(0, (\"preprocessing\", preprocessing(framework)))\n\n        super().__init__(modules)\n\n        if pretrained:\n            self.load_state_dict_from_url(framework)\n\n    @abstractmethod\n    def state_dict_url(self, framework: str) -> str:\n        r\"\"\"Select URL of a downloadable ``state_dict``.\n\n        Args:\n            framework: Name of the framework that was used to train the weights.\n\n        Raises:\n            RuntimeError: If no ``state_dict`` is available.\n        \"\"\"\n        pass\n\n    @abstractmethod\n    def collect_modules(\n        self, inplace: bool\n    ) -> Tuple[List[Tuple[str, nn.Module]], Dict[str, str]]:\n        r\"\"\"Collect modules of a base model with more descriptive names.\n\n        Args:\n            inplace: If ``True``, when possible, modules should use inplace operations.\n\n        Returns:\n            List of name-module-pairs as well as a dictionary mapping the new, more\n            descriptive names to the original ones.\n        \"\"\"\n        pass\n\n    def _map_state_dict_keys(\n        self, state_dict: Dict[str, torch.Tensor]\n    ) -> Tuple[Dict[str, torch.Tensor], List[str]]:\n        remapped_state_dict = {}\n        unexpected_keys = []\n        for key, value in state_dict.items():\n            if key in self._state_dict_key_map:\n                remapped_state_dict[self._state_dict_key_map[key]] = value\n            else:\n                unexpected_keys.append(key)\n\n        return remapped_state_dict, unexpected_keys\n\n    def load_state_dict(\n        self,\n        state_dict: Dict[str, torch.Tensor],\n        strict: bool = True,\n        map_names: bool = True,\n        framework: str = \"unknown\",\n    ) -> _IncompatibleKeys:\n        r\"\"\"Loads parameters and buffers from the ``state_dict``.\n\n        Args:\n            state_dict: State dictionary.\n            strict: Enforce matching keys in ``state_dict`` and the internal states.\n            map_names: If ``True``, maps the names names in ``state_dict`` of the\n                underlying model to the more descriptive names generated by\n                :meth:`collect_modules`. Defaults to ``True``.\n            framework: Name of the framework that was used to train the weights in\n                ``state_dict``. Defaults to ``\"unknown\"``.\n\n                .. note::\n\n                    This has no effect on the behavior, but makes the representation\n                    of the :class:`ModelMultiLayerEncoder` more descriptive.\n\n        Returns:\n            Named tuple with ``missing_keys`` and ``unexpected_keys`` fields.\n\n        .. seealso::\n\n            :meth:`torch.nn.Module.load_state_dict`\n        \"\"\"\n        if map_names:\n            state_dict, unexpected_keys = self._map_state_dict_keys(state_dict)\n        else:\n            unexpected_keys = []\n\n        keys = cast(\n            _IncompatibleKeys, super().load_state_dict(state_dict, strict=strict)\n        )\n        keys.unexpected_keys.extend(unexpected_keys)\n\n        self.pretrained = True\n        self.framework = framework\n\n        return keys\n\n    def load_state_dict_from_url(\n        self,\n        framework: str,\n        strict: bool = True,\n        map_names: bool = True,\n        check_hash: bool = True,\n        **kwargs: Any,\n    ) -> None:\n        r\"\"\"Downloads and loads parameters and buffers trained with ``framework``.\n\n        Args:\n            framework: Name of the framework that was used to train the weights of the\n                ``state_dict``.\n            strict: Enforce matching keys in ``state_dict`` and the internal states.\n            map_names: If ``True``, maps the names names in ``state_dict`` of the\n                underlying model to the more descriptive names generated by\n                :meth:`collect_modules`. Defaults to ``True``.\n            check_hash: If ``True``, checks if the hash postfix of the URL matches the\n                SHA256 hash of the downloaded ``state_dict``. Defaults to ``True``.\n            kwargs: Optional arguments for :meth:`torch.hub.load_state_dict_from_url` .\n\n        .. seealso::\n\n            - :meth:`state_dict_url`\n            - :meth:`load_state_dict`\n            - :meth:`torch.hub.load_state_dict_from_url`\n        \"\"\"\n        url = self.state_dict_url(framework)\n        state_dict = hub.load_state_dict_from_url(url, check_hash=check_hash, **kwargs)\n        self.load_state_dict(\n            state_dict, strict=strict, map_names=map_names, framework=framework\n        )\n\n    def _properties(self) -> Dict[str, Any]:\n        dct = super()._properties()\n        if not self.pretrained:\n            dct[\"pretrained\"] = False\n        else:\n            dct[\"framework\"] = self.framework\n        if not self.internal_preprocessing:\n            dct[\"internal_preprocessing\"] = self.internal_preprocessing\n        if self.allow_inplace:\n            dct[\"allow_inplace\"] = self.allow_inplace\n        return dct\n", "path": "pystiche/enc/models/utils.py"}], "after_files": [{"content": "from abc import abstractmethod\nfrom typing import Any, Callable, Dict, List, Optional, Tuple, TypeVar, cast\n\nimport torch\nfrom torch import hub, nn\nfrom torch.nn.modules.module import _IncompatibleKeys\n\nfrom ..multi_layer_encoder import MultiLayerEncoder\nfrom ..prepostprocessing import preprocessing\n\n__all__ = [\"ModelMultiLayerEncoder\", \"select_url\"]\n\nT = TypeVar(\"T\")\n\n\ndef select_url(\n    urls: Dict[T, str], key: T, format: Optional[Callable[[T], str]] = None\n) -> str:\n    if format is None:\n        format = str\n\n    try:\n        return urls[key]\n    except KeyError as error:\n        raise RuntimeError(f\"No URL is available for\\n\\n{format(key)}\") from error\n\n\nclass ModelMultiLayerEncoder(MultiLayerEncoder):\n    r\"\"\"Multi-layer encoder based on a pre-defined model.\n\n    Args:\n        pretrained: If ``True``, loads builtin weights. Defaults to ``True``.\n        framework: Name of the framework that was used to train the builtin weights.\n            Defaults to ``\"torch\"``.\n        internal_preprocessing: If ``True``, adds a preprocessing layer for the\n            selected ``framework`` as first layer. Defaults to ``True``.\n        allow_inplace: If ``True``, allows inplace operations to reduce the memory\n            requirement during the forward pass. Defaults to ``False``.\n\n            .. warning::\n                After performing an inplace operation the encodings of the previous\n                layer is no longer accessible. Only use this if you are sure that you\n                do **not** need these encodings.\n    \"\"\"\n\n    def __init__(\n        self,\n        pretrained: bool = True,\n        framework: str = \"torch\",\n        internal_preprocessing: bool = True,\n        allow_inplace: bool = False,\n    ) -> None:\n        self.pretrained = pretrained\n        self.framework = framework\n        self.internal_preprocessing = internal_preprocessing\n        self.allow_inplace = allow_inplace\n\n        modules, self._state_dict_key_map = self.collect_modules(allow_inplace)\n        if internal_preprocessing:\n            modules.insert(0, (\"preprocessing\", preprocessing(framework)))\n\n        super().__init__(modules)\n\n        if pretrained:\n            self.load_state_dict_from_url(framework)\n\n    @abstractmethod\n    def state_dict_url(self, framework: str) -> str:\n        r\"\"\"Select URL of a downloadable ``state_dict``.\n\n        Args:\n            framework: Name of the framework that was used to train the weights.\n\n        Raises:\n            RuntimeError: If no ``state_dict`` is available.\n        \"\"\"\n        pass\n\n    @abstractmethod\n    def collect_modules(\n        self, inplace: bool\n    ) -> Tuple[List[Tuple[str, nn.Module]], Dict[str, str]]:\n        r\"\"\"Collect modules of a base model with more descriptive names.\n\n        Args:\n            inplace: If ``True``, when possible, modules should use inplace operations.\n\n        Returns:\n            List of name-module-pairs as well as a dictionary mapping the new, more\n            descriptive names to the original ones.\n        \"\"\"\n        pass\n\n    def _map_state_dict_keys(\n        self, state_dict: Dict[str, torch.Tensor]\n    ) -> Tuple[Dict[str, torch.Tensor], List[str]]:\n        remapped_state_dict = {}\n        unexpected_keys = []\n        for key, value in state_dict.items():\n            if key in self._state_dict_key_map:\n                remapped_state_dict[self._state_dict_key_map[key]] = value\n            else:\n                unexpected_keys.append(key)\n\n        return remapped_state_dict, unexpected_keys\n\n    def load_state_dict(\n        self,\n        state_dict: Dict[str, torch.Tensor],\n        strict: bool = True,\n        map_names: bool = True,\n        framework: str = \"unknown\",\n    ) -> _IncompatibleKeys:\n        r\"\"\"Loads parameters and buffers from the ``state_dict``.\n\n        Args:\n            state_dict: State dictionary.\n            strict: Enforce matching keys in ``state_dict`` and the internal states.\n            map_names: If ``True``, maps the names names in ``state_dict`` of the\n                underlying model to the more descriptive names generated by\n                :meth:`collect_modules`. Defaults to ``True``.\n            framework: Name of the framework that was used to train the weights in\n                ``state_dict``. Defaults to ``\"unknown\"``.\n\n                .. note::\n\n                    This has no effect on the behavior, but makes the representation\n                    of the :class:`ModelMultiLayerEncoder` more descriptive.\n\n        Returns:\n            Named tuple with ``missing_keys`` and ``unexpected_keys`` fields.\n\n        .. seealso::\n\n            :meth:`torch.nn.Module.load_state_dict`\n        \"\"\"\n        if map_names:\n            state_dict, unexpected_keys = self._map_state_dict_keys(state_dict)\n        else:\n            unexpected_keys = []\n\n        keys = cast(\n            _IncompatibleKeys, super().load_state_dict(state_dict, strict=strict)\n        )\n        keys.unexpected_keys.extend(unexpected_keys)\n\n        self.pretrained = True\n        self.framework = framework\n\n        return keys\n\n    def load_state_dict_from_url(\n        self,\n        framework: str,\n        strict: bool = True,\n        map_names: bool = True,\n        check_hash: bool = True,\n        **kwargs: Any,\n    ) -> None:\n        r\"\"\"Downloads and loads parameters and buffers trained with ``framework``.\n\n        Args:\n            framework: Name of the framework that was used to train the weights of the\n                ``state_dict``.\n            strict: Enforce matching keys in ``state_dict`` and the internal states.\n            map_names: If ``True``, maps the names names in ``state_dict`` of the\n                underlying model to the more descriptive names generated by\n                :meth:`collect_modules`. Defaults to ``True``.\n            check_hash: If ``True``, checks if the hash postfix of the URL matches the\n                SHA256 hash of the downloaded ``state_dict``. Defaults to ``True``.\n            kwargs: Optional arguments for :meth:`torch.hub.load_state_dict_from_url` .\n\n        .. seealso::\n\n            - :meth:`state_dict_url`\n            - :meth:`load_state_dict`\n            - :meth:`torch.hub.load_state_dict_from_url`\n        \"\"\"\n        url = self.state_dict_url(framework)\n        state_dict = hub.load_state_dict_from_url(url, check_hash=check_hash, **kwargs)\n        self.load_state_dict(\n            state_dict, strict=strict, map_names=map_names, framework=framework\n        )\n\n    def _properties(self) -> Dict[str, Any]:\n        dct = super()._properties()\n        if not self.pretrained:\n            dct[\"pretrained\"] = False\n        else:\n            dct[\"framework\"] = self.framework\n        if not self.internal_preprocessing:\n            dct[\"internal_preprocessing\"] = self.internal_preprocessing\n        if self.allow_inplace:\n            dct[\"allow_inplace\"] = self.allow_inplace\n        return dct\n", "path": "pystiche/enc/models/utils.py"}]}