rom collections import OrderedDict, namedtuple
import func
tools
import iter
tools
import warn
ings
import
torch
from ..parameter import Parameter
import
torch.utils.hooks as hooks
from
torch import
Tensor, device, dtype
from typ
ing import Union, Tuple, Any, Callable, Itera
tor, Set, Optional, overload, TypeVar, Mapp
ing, Dict
from ...utils.hooks import RemovableHandle
_grad_t = Union[Tuple[
Tensor, ...],
Tensor]
# See https://mypy.readthedocs.io/en/latest/generics.html#generic-methods-and-generic-self for the use
#
of `T`
to annotate `self`. Many methods
of `Module` return `self` and we want those return values
to be
# the type
of the subclass, not the looser type
of `Module`.
T = TypeVar('T', bound='Module')
class _
IncompatibleKeys(namedtuple('
IncompatibleKeys', ['miss
ing_keys', 'unexpected_keys'])):
def __repr__(self):
if not self.miss
ing_keys and not self.unexpected_keys:
return '<All keys matched successfully>'
return super(_
IncompatibleKeys, self).__repr__()
__str__ = __repr__
class ModuleAttributeError(AttributeError):
""" When `__getattr__` raises AttributeError
inside a property,
AttributeError is raised with the property name
instead
of the
attribute that
initially raised AttributeError, mak
ing the error
message un
informative. Us
ing `ModuleAttributeError`
instead
fixes this issue."""
def _add
indent(s_, numSpaces):
s = s_.split('\n')
# don't do anyth
ing for s
ingle-l
ine stuff
if len(s) == 1:
return s_
first = s.pop(0)
s = [(numSpaces * ' ') + l
ine for l
ine
in s]
s = '\n'.jo
in(s)
s = first + '\n' + s
return s
r"""This tracks hooks common
to all modules that are executed before/after
call
ing forward and backward. This is global state used for debugg
ing/pr
ofil
ing
purposes"""
_global_backward_hooks = OrderedDict()
_global_forward_pre_hooks = OrderedDict()
_global_forward_hooks = OrderedDict()
def register_module_forward_pre_hook(hook: Callable[..., None]) -> RemovableHandle:
r"""Registers a forward pre-hook common
to all modules.
.. warn
ing ::
This adds global state
to the `nn.module` module
and it is only
intended for debugg
ing/pr
ofil
ing purposes.
The hook will be called every time before :func:`forward` is
invoked.
It should have the follow
ing signature::
hook(module,
input) -> None or modified
input
The
input conta
ins only the positional arguments given
to the module.
Keyword arguments won't be passed
to the hooks and only
to the ``forward``.
The hook can modify the
input. User can either return a tuple or a
s
ingle modified value
in the hook. We will wrap the value
into a tuple
if a s
ingle value is returned(unless that value is already a tuple).
This hook has precedence over the specific module hooks registered with
``register_forward_pre_hook``.
Returns:
:class:`
torch.utils.hooks.RemovableHandle`:
a handle that can be used
to remove the added hook by call
ing
``handle.remove()``
"""
handle = hooks.RemovableHandle(_global_forward_pre_hooks)
_global_forward_pre_hooks[handle.id] = hook
return handle
def register_module_forward_hook(hook: Callable[..., None]) -> RemovableHandle:
r"""Registers a global forward hook for all the modules
.. warn
ing ::
This adds global state
to the `nn.module` module
and it is only
intended for debugg
ing/pr
ofil
ing purposes.
The hook will be called every time after :func:`forward` has computed an output.
It should have the follow
ing signature::
hook(module,
input, output) -> None or modified output
The
input conta
ins only the positional arguments given
to the module.
Keyword arguments won't be passed
to the hooks and only
to the ``forward``.
The hook can modify the output. It can modify the
input
inplace but
it will not have effect on forward s
ince this is called after
:func:`forward` is called.
Returns:
:class:`
torch.utils.hooks.RemovableHandle`:
a handle that can be used
to remove the added hook by call
ing
``handle.remove()``
This hook will be executed before specific module hooks registered with
``register_forward_hook``.
"""
handle = hooks.RemovableHandle(_global_forward_hooks)
_global_forward_hooks[handle.id] = hook
return handle
def register_module_backward_hook(
hook: Callable[['Module', _grad_t, _grad_t], Union[None,
Tensor]]
) -> RemovableHandle:
r"""Registers a backward hook common
to all the modules.
.. warn
ing ::
This adds global state
to the `nn.module` module
and it is only
intended for debugg
ing/pr
ofil
ing purposes.
The current implementation will not have the presented behavior
for complex :class:`Module` that perform many operations.
In some failure cases, :attr:`grad_
input` and :attr:`grad_output` will only
conta
in the gradients for a subset
of the
inputs and outputs.
For such :class:`Module`, you should use :func:`
torch.
Tensor.register_hook`
directly on a specific
input or output
to get the required gradients.
The hook will be called every time the gradients with respect
to module
inputs are computed. The hook should have the follow
ing signature::
hook(module, grad_
input, grad_output) ->
Tensor or None
The :attr:`grad_
input` and :attr:`grad_output` may be tuples if the
module has multiple
inputs or outputs. The hook should not modify its
arguments, but it can optionally return a new gradient with respect
to
input that will be used
in place
of :attr:`grad_
input`
in subsequent
computations. :attr:`grad_
input` will only correspond
to the
inputs given
as positional arguments.
Global hooks are called before hooks registered with `register_backward_hook`
Returns:
:class:`
torch.utils.hooks.RemovableHandle`:
a handle that can be used
to remove the added hook by call
ing
``handle.remove()``
"""
handle = hooks.RemovableHandle(_global_backward_hooks)
_global_backward_hooks[handle.id] = hook
return handle
# Trick mypy
into not apply
ing contravariance rules
to inputs by def
ining
# forward as a value, rather than a function. See also
# https://github.com/
python/mypy/issues/8795
def _forward_unimplemented(self, *
input: Any) -> None:
r"""Def
ines the computation performed at every call.
Should be overridden by all subclasses.
.. note::
Although the recipe for forward pass needs
to be def
ined with
in
this function, one should call the :class:`Module`
instance afterwards
instead
of this s
ince the former takes care
of runn
ing the
registered hooks while the latter silently ignores them.
"""
raise NotImplementedError
class Module:
r"""Base class for all neural network modules.
Your models should also subclass this class.
Modules can also conta
in other Modules, allow
ing
to nest them
in
a tree structure. You can assign the submodules as regular attributes::
import
torch.nn as nn
import
torch.nn.functional as F
class Model(nn.Module):
def __
init__(self):
super(Model, self).__
init__()
self.conv1 = nn.Conv2d(1, 20, 5)
self.conv2 = nn.Conv2d(20, 20, 5)
def forward(self, x):
x = F.relu(self.conv1(x))
return F.relu(self.conv2(x))
Submodules assigned
in this way will be registered, and will have their
parameters
converted
too when you call :meth:`
to`, etc.
:ivar tra
ining: Boolean represents whether this module is
in tra
ining or
evaluation mode.
:vartype tra
ining: bool
"""
dump_patches: bool = False
r"""This allows better BC support for :meth:`load_state_dict`.
In
:meth:`state_dict`, the version number will be saved as
in the attribute
`_metadata`
of the returned state dict, and thus pickled. `_metadata` is a
dictionary with keys that follow the nam
ing convention
of state dict. See
``_load_from_state_dict`` on
how to use this
information
in load
ing.
If new parameters/buffers are added/removed from a module, this number shall
be bumped, and the module's `_load_from_state_dict` method can compare the
version number and do appropriate changes if the state dict is from before
the change."""
_version:
int = 1
tra
ining: bool
def __
init__(self):
"""
Initializes
internal Module state, shared by both nn.Module and ScriptModule.
"""
torch._C._log_api_usage_once("
python.nn_module")
self.tra
ining = True
self._parameters = OrderedDict()
self._buffers = OrderedDict()
self._non_persistent_buffers_set = set()
self._backward_hooks = OrderedDict()
self._forward_hooks = OrderedDict()
self._forward_pre_hooks = OrderedDict()
self._state_dict_hooks = OrderedDict()
self._load_state_dict_pre_hooks = OrderedDict()
self._modules = OrderedDict()
forward: Callable[..., Any] = _forward_unimplemented
def register_buffer(self, name: str,
tensor: Optional[
Tensor], persistent: bool = True) -> None:
r"""Adds a buffer
to the module.
This is typically used
to register a buffer that should not
to be
considered a model parameter. For example, BatchNorm's ``runn
ing_mean``
is not a parameter, but is part
of the module's state. Buffers, by
default, are persistent and will be saved alongside parameters. This
behavior can be changed by sett
ing :attr:`persistent`
to ``False``. The
only difference between a persistent buffer and a non-persistent buffer
is that the latter will not be a part
of this module's
:attr:`state_dict`.
Buffers can be accessed as attributes us
ing given names.
Args:
name (str
ing): name
of the buffer. The buffer can be accessed
from this module us
ing the given name
tensor (
Tensor): buffer
to be registered.
persistent (bool): whether the buffer is part
of this module's
:attr:`state_dict`.
Example::
>>> self.register_buffer('runn
ing_mean',
torch.zeros(num_features))
"""
if persistent is False and is
instance(self,
torch.jit.ScriptModule):
raise RuntimeError("ScriptModule does not support non-persistent buffers")
if '_buffers' not
in self.__dict__:
raise AttributeError(
"cannot assign buffer before Module.__
init__() call")
elif not is
instance(name,
torch._six.str
ing_classes):
raise TypeError("buffer name should be a str
ing. "
"Got {}".format(
torch.typename(name)))
elif '.'
in name:
raise KeyError("buffer name can't conta
in \".\"")
elif name == '':
raise KeyError("buffer name can't be empty str
ing \"\"")
elif hasattr(self, name) and name not
in self._buffers:
raise KeyError("attribute '{}' already exists".format(name))
elif
tensor is not None and not is
instance(
tensor,
torch.
Tensor):
raise TypeError("cannot assign '{}' object
to buffer '{}' "
"(
torch
Tensor or None required)"
.format(
torch.typename(
tensor), name))
else:
self._buffers[name] =
tensor
if persistent:
self._non_persistent_buffers_set.discard(name)
else:
self._non_persistent_buffers_set.add(name)
def register_parameter(self, name: str, param: Optional[Parameter]) -> None:
r"""Adds a parameter
to the module.
The parameter can be accessed as an attribute us
ing given name.
Args:
name (str
ing): name
of the parameter. The parameter can be accessed
from this module us
ing the given name
param (Parameter): parameter
to be added
to the module.
"""
if '_parameters' not
in self.__dict__:
raise AttributeError(
"cannot assign parameter before Module.__
init__() call")
elif not is
instance(name,
torch._six.str
ing_classes):
raise TypeError("parameter name should be a str
ing. "
"Got {}".format(
torch.typename(name)))
elif '.'
in name:
raise KeyError("parameter name can't conta
in \".\"")
elif name == '':
raise KeyError("parameter name can't be empty str
ing \"\"")
elif hasattr(self, name) and name not
in self._parameters:
raise KeyError("attribute '{}' already exists".format(name))
if param is None:
self._parameters[name] = None
elif not is
instance(param, Parameter):
raise TypeError("cannot assign '{}' object
to parameter '{}' "
"(
torch.nn.Parameter or None required)"
.format(
torch.typename(param), name))
elif param.grad_fn:
raise ValueError(
"Cannot assign non-leaf
Tensor to parameter '{0}'. Model "
"parameters must be created explicitly.
To express '{0}' "
"as a function
of another
Tensor, compute the value
in "
"the forward() method.".format(name))
else:
self._parameters[name] = param
def add_module(self, name: str, module: Optional['Module']) -> None:
r"""Adds a child module
to the current module.
The module can be accessed as an attribute us
ing the given name.
Args:
name (str
ing): name
of the child module. The child module can be
accessed from this module us
ing the given name
module (Module): child module
to be added
to the module.
"""
if not is
instance(module, Module) and module is not None:
raise TypeError("{} is not a Module subclass".format(
torch.typename(module)))
elif not is
instance(name,
torch._six.str
ing_classes):
raise TypeError("module name should be a str
ing. Got {}".format(
torch.typename(name)))
elif hasattr(self, name) and name not
in self._modules:
raise KeyError("attribute '{}' already exists".format(name))
elif '.'
in name:
raise KeyError("module name can't conta
in \".\"")
elif name == '':
raise KeyError("module name can't be empty str
ing \"\"")
self._modules[name] = module
def _apply(self, fn):
for module
in self.children():
module._apply(fn)
def compute_should_use_set_data(
tensor,
tensor_applied):
if
torch._has_compatible_shallow_copy_type(
tensor,
tensor_applied):
# If the new
tensor has compatible
tensor type as the exist
ing
tensor,
# the current behavior is
to change the
tensor in-place us
ing `.data =`,
# and the future behavior is
to overwrite the exist
ing
tensor.
However,
# chang
ing the current behavior is a BC-break
ing change, and we want it
#
to happen
in future releases. So for now we
introduce the
# `
torch.__future__.get_overwrite_module_params_on_conversion()`
# global flag
to let the user control whether they want the future
# behavior
of overwrit
ing the exist
ing
tensor or not.
return not
torch.__future__.get_overwrite_module_params_on_conversion()
else:
return False
for key, param
in self._parameters.items():
if param is not None:
#
Tensors s
tored
in modules are graph leaves, and we don't want
to
# track au
tograd his
tory
of `param_applied`, so we have
to use
# `with
torch.no_grad():`
with
torch.no_grad():
param_applied = fn(param)
should_use_set_data = compute_should_use_set_data(param, param_applied)
if should_use_set_data:
param.data = param_applied
else:
assert is
instance(param, Parameter)
assert param.is_leaf
self._parameters[key] = Parameter(param_applied, param.requires_grad)
if param.grad is not None:
with
torch.no_grad():
grad_applied = fn(param.grad)
should_use_set_data = compute_should_use_set_data(param.grad, grad_applied)
if should_use_set_data:
param.grad.data = grad_applied
else:
assert param.grad.is_leaf
self._parameters[key].grad = grad_applied.requires_grad_(param.grad.requires_grad)
for key, buf
in self._buffers.items():
if buf is not None:
self._buffers[key] = fn(buf)
return self
def apply(self: T, fn: Callable[['Module'], None]) -> T:
r"""Applies ``fn`` recursively
to every submodule (as returned by ``.children()``)
as well as self. Typical use
includes
initializ
ing the parameters
of a model
(see also :ref:`nn-
init-doc`).
Args:
fn (:class:`Module` -> None): function
to be applied
to each submodule
Returns:
Module: self
Example::
>>> @
torch.no_grad()
>>> def
init_weights(m):
>>> pr
int(m)
>>> if type(m) == nn.L
inear:
>>> m.weight.fill_(1.0)
>>> pr
int(m.weight)
>>> net = nn.Sequential(nn.L
inear(2, 2), nn.L
inear(2, 2))
>>> net.apply(
init_weights)
L
inear(
in_features=2, out_features=2, bias=True)
Parameter conta
ining:
tensor([[ 1., 1.],
[ 1., 1.]])
L
inear(
in_features=2, out_features=2, bias=True)
Parameter conta
ining:
tensor([[ 1., 1.],
[ 1., 1.]])
Sequential(
(0): L
inear(
in_features=2, out_features=2, bias=True)
(1): L
inear(
in_features=2, out_features=2, bias=True)
)
Sequential(
(0): L
inear(
in_features=2, out_features=2, bias=True)
(1): L
inear(
in_features=2, out_features=2, bias=True)
)
"""
for module
in self.children():
module.apply(fn)
fn(self)
return self
def cuda(self: T, device: Optional[Union[
int, device]] = None) -> T:
r"""Moves all model parameters and buffers
to the GPU.
This also makes associated parameters and buffers different objects. So
it should be called before construct
ing optimizer if the module will
live on GPU while be
ing optimized.
Arguments:
device (
int, optional): if specified, all parameters will be
copied
to that device
Returns:
Module: self
"""
return self._apply(lambda t: t.cuda(device))
def cpu(self: T) -> T:
r"""Moves all model parameters and buffers
to the CPU.
Returns:
Module: self
"""
return self._apply(lambda t: t.cpu())
def type(self: T, dst_type: Union[dtype, str]) -> T:
r"""Casts all parameters and buffers
to :attr:`dst_type`.
Arguments:
dst_type (type or str
ing): the desired type
Returns:
Module: self
"""
return self._apply(lambda t: t.type(dst_type))
def float(self: T) -> T:
r"""Casts all float
ing po
int parameters and buffers
to float datatype.
Returns:
Module: self
"""
return self._apply(lambda t: t.float() if t.is_float
ing_po
int() else t)
def double(self: T) -> T:
r"""Casts all float
ing po
int parameters and buffers
to ``double`` datatype.
Returns:
Module: self
"""
return self._apply(lambda t: t.double() if t.is_float
ing_po
int() else t)
def half(self: T) -> T:
r"""Casts all float
ing po
int parameters and buffers
to ``half`` datatype.
Returns:
Module: self
"""
return self._apply(lambda t: t.half() if t.is_float
ing_po
int() else t)
def bfloat16(self: T) -> T:
r"""Casts all float
ing po
int parameters and buffers
to ``bfloat16`` datatype.
Returns:
Module: self
"""
return self._apply(lambda t: t.bfloat16() if t.is_float
ing_po
int() else t)
@overload
def
to(self: T, device: Optional[Union[
int, device]] = ..., dtype: Optional[Union[dtype, str]] = ...,
non_block
ing: bool = ...) -> T:
...
@overload
def
to(self: T, dtype: Union[dtype, str], non_block
ing: bool = ...) -> T:
...
@overload
def
to(self: T,
tensor:
Tensor, non_block
ing: bool = ...) -> T:
...
def
to(self, *args, **kwargs):
r"""Moves and/or casts the parameters and buffers.
This can be called as
.. function::
to(device=None, dtype=None, non_block
ing=False)
.. function::
to(dtype, non_block
ing=False)
.. function::
to(
tensor, non_block
ing=False)
.. function::
to(memory_format=
torch.channels_last)
Its signature is similar
to :meth:`
torch.
Tensor.
to`, but only accepts
float
ing po
int desired :attr:`dtype` s.
In addition, this method will
only cast the float
ing po
int parameters and buffers
to :attr:`dtype`
(if given). The
integral parameters and buffers will be moved
:attr:`device`, if that is given, but with dtypes unchanged. When
:attr:`non_block
ing` is set, it tries
to convert/move asynchronously
with respect
to the host if possible, e.g., mov
ing CPU
Tensors with
p
inned memory
to CUDA devices.
See below for examples.
.. note::
This method modifies the module
in-place.
Args:
device (:class:`
torch.device`): the desired device
of the parameters
and buffers
in this module
dtype (:class:`
torch.dtype`): the desired float
ing po
int type
of
the float
ing po
int parameters and buffers
in this module
tensor (
torch.
Tensor):
Tensor whose dtype and device are the desired
dtype and device for all parameters and buffers
in this module
memory_format (:class:`
torch.memory_format`): the desired memory
format for 4D parameters and buffers
in this module (keyword
only argument)
Returns:
Module: self
Example::
>>> l
inear = nn.L
inear(2, 2)
>>> l
inear.weight
Parameter conta
ining:
tensor([[ 0.1913, -0.3420],
[-0.5113, -0.2325]])
>>> l
inear.
to(
torch.double)
L
inear(
in_features=2, out_features=2, bias=True)
>>> l
inear.weight
Parameter conta
ining:
tensor([[ 0.1913, -0.3420],
[-0.5113, -0.2325]], dtype=
torch.float64)
>>> gpu1 =
torch.device("cuda:1")
>>> l
inear.
to(gpu1, dtype=
torch.half, non_block
ing=True)
L
inear(
in_features=2, out_features=2, bias=True)
>>> l
inear.weight
Parameter conta
ining:
tensor([[ 0.1914, -0.3420],
[-0.5112, -0.2324]], dtype=
torch.float16, device='cuda:1')
>>> cpu =
torch.device("cpu")
>>> l
inear.
to(cpu)
L
inear(
in_features=2, out_features=2, bias=True)
>>> l
inear.weight
Parameter conta
ining:
tensor([[ 0.1914, -0.3420],
[-0.5112, -0.2324]], dtype=
torch.float16)
"""
device, dtype, non_block
ing,
convert_
to_format =
torch._C._nn._parse_
to(*args, **kwargs)
if dtype is not None:
if not dtype.is_float
ing_po
int:
raise TypeError('nn.Module.
to only accepts float
ing po
int '
'dtypes, but got desired dtype={}'.format(dtype))
def
convert(t):
if
convert_
to_format is not None and t.dim() == 4:
return t.
to(device, dtype if t.is_float
ing_po
int() else None, non_block
ing, memory_format=
convert_
to_format)
return t.
to(device, dtype if t.is_float
ing_po
int() else None, non_block
ing)
return self._apply(
convert)
def register_backward_hook(
self, hook: Callable[['Module', _grad_t, _grad_t], Union[None,
Tensor]]
) -> RemovableHandle:
r"""Registers a backward hook on the module.
.. warn
ing ::
The current implementation will not have the presented behavior
for complex :class:`Module` that perform many operations.
In some failure cases, :attr:`grad_
input` and :attr:`grad_output` will only
conta
in the gradients for a subset
of the
inputs and outputs.
For such :class:`Module`, you should use :func:`
torch.
Tensor.register_hook`
directly on a specific
input or output
to get the required gradients.
The hook will be called every time the gradients with respect
to module
inputs are computed. The hook should have the follow
ing signature::
hook(module, grad_
input, grad_output) ->
Tensor or None
The :attr:`grad_
input` and :attr:`grad_output` may be tuples if the
module has multiple
inputs or outputs. The hook should not modify its
arguments, but it can optionally return a new gradient with respect
to
input that will be used
in place
of :attr:`grad_
input`
in subsequent
computations. :attr:`grad_
input` will only correspond
to the
inputs given
as positional arguments.
Returns:
:class:`
torch.utils.hooks.RemovableHandle`:
a handle that can be used
to remove the added hook by call
ing
``handle.remove()``
"""
handle = hooks.RemovableHandle(self._backward_hooks)
self._backward_hooks[handle.id] = hook
return handle
def register_forward_pre_hook(self, hook: Callable[..., None]) -> RemovableHandle:
r"""Registers a forward pre-hook on the module.
The hook will be called every time before :func:`forward` is
invoked.
It should have the follow
ing signature::
hook(module,
input) -> None or modified
input
The
input conta
ins only the positional arguments given
to the module.
Keyword arguments won't be passed
to the hooks and only
to the ``forward``.
The hook can modify the
input. User can either return a tuple or a
s
ingle modified value
in the hook. We will wrap the value
into a tuple
if a s
ingle value is returned(unless that value is already a tuple).
Returns:
:class:`
torch.utils.hooks.RemovableHandle`:
a handle that can be used
to remove the added hook by call
ing
``handle.remove()``
"""
handle = hooks.RemovableHandle(self._forward_pre_hooks)
self._forward_pre_hooks[handle.id] = hook
return handle
def register_forward_hook(self, hook: Callable[..., None]) -> RemovableHandle:
r"""Registers a forward hook on the module.
The hook will be called every time after :func:`forward` has computed an output.
It should have the follow
ing signature::
hook(module,
input, output) -> None or modified output
The
input conta
ins only the positional arguments given
to the module.
Keyword arguments won't be passed
to the hooks and only
to the ``forward``.
The hook can modify the output. It can modify the
input
inplace but
it will not have effect on forward s
ince this is called after
:func:`forward` is called.
Returns:
:class:`
torch.utils.hooks.RemovableHandle`:
a handle that can be used
to remove the added hook by call
ing
``handle.remove()``
"""
handle = hooks.RemovableHandle(self._forward_hooks)
self._forward_hooks[handle.id] = hook
return handle
def _slow_forward(self, *
input, **kwargs):
trac
ing_state =
torch._C._get_trac
ing_state()
if not trac
ing_state or is
instance(self.forward,
torch._C.ScriptMethod):
return self.forward(*
input, **kwargs)
record
ing_scopes =
torch.jit._trace._trace_module_map is not None
if record
ing_scopes:
name =
torch.jit._trace._trace_module_map[self] if self
in torch.jit._trace._trace_module_map else None
if name:
cur_scope_name = trac
ing_state.current_scope()
trac
ing_state.push_scope(name)
else:
record
ing_scopes = False
try:
result = self.forward(*
input, **kwargs)
f
inally:
if record
ing_scopes:
trac
ing_state.pop_scope()
return result
def _call_impl(self, *
input, **kwargs):
for hook
in iter
tools.cha
in(
_global_forward_pre_hooks.values(),
self._forward_pre_hooks.values()):
result = hook(self,
input)
if result is not None:
if not is
instance(result, tuple):
result = (result,)
input = result
if
torch._C._get_trac
ing_state():
result = self._slow_forward(*
input, **kwargs)
else:
result = self.forward(*
input, **kwargs)
for hook
in iter
tools.cha
in(
_global_forward_hooks.values(),
self._forward_hooks.values()):
hook_result = hook(self,
input, result)
if hook_result is not None:
result = hook_result
if (len(self._backward_hooks) > 0) or (len(_global_backward_hooks) > 0):
var = result
while not is
instance(var,
torch.
Tensor):
if is
instance(var, dict):
var = next((v for v
in var.values() if is
instance(v,
torch.
Tensor)))
else:
var = var[0]
grad_fn = var.grad_fn
if grad_fn is not None:
for hook
in iter
tools.cha
in(
_global_backward_hooks.values(),
self._backward_hooks.values()):
wrapper = func
tools.partial(hook, self)
func
tools.update_wrapper(wrapper, hook)
grad_fn.register_hook(wrapper)
return result
__call__ : Callable[..., Any] = _call_impl
def __setstate__(self, state):
self.__dict__.update(state)
# Support load
ing old checkpo
ints that don't have the follow
ing attrs:
if '_forward_pre_hooks' not
in self.__dict__:
self._forward_pre_hooks = OrderedDict()
if '_state_dict_hooks' not
in self.__dict__:
self._state_dict_hooks = OrderedDict()
if '_load_state_dict_pre_hooks' not
in self.__dict__:
self._load_state_dict_pre_hooks = OrderedDict()
if '_non_persistent_buffers_set' not
in self.__dict__:
self._non_persistent_buffers_set = set()
def __getattr__(self, name: str) -> Union[
Tensor, 'Module']:
if '_parameters'
in self.__dict__:
_parameters = self.__dict__['_parameters']
if name
in _parameters:
return _parameters[name]
if '_buffers'
in self.__dict__:
_buffers = self.__dict__['_buffers']
if name
in _buffers:
return _buffers[name]
if '_modules'
in self.__dict__:
modules = self.__dict__['_modules']
if name
in modules:
return modules[name]
raise ModuleAttributeError("'{}' object has no attribute '{}'".format(
type(self).__name__, name))
def __setattr__(self, name: str, value: Union[
Tensor, 'Module']) -> None:
def remove_from(*dicts_or_sets):
for d
in dicts_or_sets:
if name
in d:
if is
instance(d, dict):
del d[name]
else:
d.discard(name)
params = self.__dict__.get('_parameters')
if is
instance(value, Parameter):
if params is None:
raise AttributeError(
"cannot assign parameters before Module.__
init__() call")
remove_from(self.__dict__, self._buffers, self._modules, self._non_persistent_buffers_set)
self.register_parameter(name, value)
elif params is not None and name
in params:
if value is not None:
raise TypeError("cannot assign '{}' as parameter '{}' "
"(
torch.nn.Parameter or None expected)"
.format(
torch.typename(value), name))
self.register_parameter(name, value)
else:
modules = self.__dict__.get('_modules')
if is
instance(value, Module):
if modules is None:
raise AttributeError(
"cannot assign module before Module.__
init__() call")
remove_from(self.__dict__, self._parameters, self._buffers, self._non_persistent_buffers_set)
modules[name] = value
elif modules is not None and name
in modules:
if value is not None:
raise TypeError("cannot assign '{}' as child module '{}' "
"(
torch.nn.Module or None expected)"
.format(
torch.typename(value), name))
modules[name] = value
else:
buffers = self.__dict__.get('_buffers')
if buffers is not None and name
in buffers:
if value is not None and not is
instance(value,
torch.
Tensor):
raise TypeError("cannot assign '{}' as buffer '{}' "
"(
torch.
Tensor or None expected)"
.format(
torch.typename(value), name))
buffers[name] = value
else:
object.__setattr__(self, name, value)
def __delattr__(self, name):
if name
in self._parameters:
del self._parameters[name]
elif name
in self._buffers:
del self._buffers[name]
self._non_persistent_buffers_set.discard(name)
elif name
in self._modules:
del self._modules[name]
else:
object.__delattr__(self, name)
def _register_state_dict_hook(self, hook):
r"""These hooks will be called with arguments: `self`, `state_dict`,
`prefix`, `local_metadata`, after the `state_dict`
of `self` is set.
Note that only parameters and buffers
of `self` or its children are
guaranteed
to exist
in `state_dict`. The hooks may modify `state_dict`
inplace or return a new one.
"""
handle = hooks.RemovableHandle(self._state_dict_hooks)
self._state_dict_hooks[handle.id] = hook
return handle
def _save_
to_state_dict(self, dest
ination, prefix, keep_vars):
r"""Saves module state
to `dest
ination` dictionary, conta
ining a state
of the module, but not its descendants. This is called on every
submodule
in :meth:`~
torch.nn.Module.state_dict`.
In rare cases, subclasses can achieve class-specific behavior by
overrid
ing this method with cus
tom logic.
Arguments:
dest
ination (dict): a dict where state will be s
tored
prefix (str): the prefix for parameters and buffers used
in this
module
"""
for name, param
in self._parameters.items():
if param is not None:
dest
ination[prefix + name] = param if keep_vars else param.detach()
for name, buf
in self._buffers.items():
if buf is not None and name not
in self._non_persistent_buffers_set:
dest
ination[prefix + name] = buf if keep_vars else buf.detach()
# The user can pass an optional arbitrary mappable object
to `state_dict`,
in which case `state_dict` returns
# back that same object. But if they pass noth
ing, an `OrederedDict` is created and returned.
T_dest
ination = TypeVar('T_dest
ination', bound=Mapp
ing[str,
Tensor])
@overload
def state_dict(self, dest
ination: T_dest
ination, prefix: str = ..., keep_vars: bool = ...) -> T_dest
ination:
...
#
TODO: annotate with OrderedDict not Dict, but there is a problem:
# https://docs.
python.org/3/library/typ
ing.html#typ
ing.OrderedDict
@overload
def state_dict(self, prefix: str = ..., keep_vars: bool = ...) -> Dict[str,
Tensor]:
...
def state_dict(self, dest
ination=None, prefix='', keep_vars=False):
r"""Returns a dictionary conta
ining a whole state
of the module.
Both parameters and persistent buffers (e.g. runn
ing averages) are
included. Keys are correspond
ing parameter and buffer names.
Returns:
dict:
a dictionary conta
ining a whole state
of the module
Example::
>>> module.state_dict().keys()
['bias', 'weight']
"""
if dest
ination is None:
dest
ination = OrderedDict()
dest
ination._metadata = OrderedDict()
dest
ination._metadata[prefix[:-1]] = local_metadata = dict(version=self._version)
self._save_
to_state_dict(dest
ination, prefix, keep_vars)
for name, module
in self._modules.items():
if module is not None:
module.state_dict(dest
ination, prefix + name + '.', keep_vars=keep_vars)
for hook
in self._state_dict_hooks.values():
hook_result = hook(self, dest
ination, prefix, local_metadata)
if hook_result is not None:
dest
ination = hook_result
return dest
ination
def _register_load_state_dict_pre_hook(self, hook):
r"""These hooks will be called with arguments: `state_dict`, `prefix`,
`local_metadata`, `strict`, `miss
ing_keys`, `unexpected_keys`,
`error_msgs`, before load
ing `state_dict`
into `self`. These arguments
are exactly the same as those
of `_load_from_state_dict`.
"""
handle = hooks.RemovableHandle(self._load_state_dict_pre_hooks)
self._load_state_dict_pre_hooks[handle.id] = hook
return handle
def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,
miss
ing_keys, unexpected_keys, error_msgs):
r"""Copies parameters and buffers from :attr:`state_dict`
into only
this module, but not its descendants. This is called on every submodule
in :meth:`~
torch.nn.Module.load_state_dict`. Metadata saved for this
module
in input :attr:`state_dict` is provided as :attr:`local_metadata`.
For state dicts without metadata, :attr:`local_metadata` is empty.
Subclasses can achieve class-specific backward compatible load
ing us
ing
the version number at `local_metadata.get("version", None)`.
.. note::
:attr:`state_dict` is not the same object as the
input
:attr:`state_dict`
to :meth:`~
torch.nn.Module.load_state_dict`. So
it can be modified.
Arguments:
state_dict (dict): a dict conta
ining parameters and
persistent buffers.
prefix (str): the prefix for parameters and buffers used
in this
module
local_metadata (dict): a dict conta
ining the metadata for this module.
See
strict (bool): whether
to strictly enforce that the keys
in
:attr:`state_dict` with :attr:`prefix` match the names
of
parameters and buffers
in this module
miss
ing_keys (
list of str): if ``strict=True``, add miss
ing keys
to
this
list
unexpected_keys (
list of str): if ``strict=True``, add unexpected
keys
to this
list
error_msgs (
list of str): error messages should be added
to this
list, and will be reported
together
in
:meth:`~
torch.nn.Module.load_state_dict`
"""
for hook
in self._load_state_dict_pre_hooks.values():
hook(state_dict, prefix, local_metadata, strict, miss
ing_keys, unexpected_keys, error_msgs)
persistent_buffers = {k: v for k, v
in self._buffers.items() if k not
in self._non_persistent_buffers_set}
local_name_params = iter
tools.cha
in(self._parameters.items(), persistent_buffers.items())
local_state = {k: v for k, v
in local_name_params if v is not None}
for name, param
in local_state.items():
key = prefix + name
if key
in state_dict:
input_param = state_dict[key]
# Backward compatibility: load
ing 1-dim
tensor from 0.3.*
to version 0.4+
if len(param.shape) == 0 and len(
input_param.shape) == 1:
input_param =
input_param[0]
if
input_param.shape != param.shape:
# local shape should match the one
in checkpo
int
error_msgs.append('size mismatch for {}: copy
ing a param with shape {} from checkpo
int, '
'the shape
in current model is {}.'
.format(key,
input_param.shape, param.shape))
cont
inue
try:
with
torch.no_grad():
param.copy_(
input_param)
except Exception as ex:
error_msgs.append('While copy
ing the parameter named "{}", '
'whose dimensions
in the model are {} and '
'whose dimensions
in the checkpo
int are {}, '
'an exception occurred : {}.'
.format(key, param.size(),
input_param.size(), ex.args))
elif strict:
miss
ing_keys.append(key)
if strict:
for key
in state_dict.keys():
if key.startswith(prefix):
input_name = key[len(prefix):]
input_name =
input_name.split('.', 1)[0] # get the name
of param/buffer/child
if
input_name not
in self._modules and
input_name not
in local_state:
unexpected_keys.append(key)
def load_state_dict(self, state_dict: Union[Dict[str,
Tensor], Dict[str,
Tensor]],
strict: bool = True):
r"""Copies parameters and buffers from :attr:`state_dict`
into
this module and its descendants. If :attr:`strict` is ``True``, then
the keys
of :attr:`state_dict` must exactly match the keys returned
by this module's :meth:`~
torch.nn.Module.state_dict` function.
Arguments:
state_dict (dict): a dict conta
ining parameters and
persistent buffers.
strict (bool, optional): whether
to strictly enforce that the keys
in :attr:`state_dict` match the keys returned by this module's
:meth:`~
torch.nn.Module.state_dict` function. Default: ``True``
Returns:
``NamedTuple`` with ``miss
ing_keys`` and ``unexpected_keys`` fields:
* **miss
ing_keys** is a
list of str conta
ining the miss
ing keys
* **unexpected_keys** is a
list of str conta
ining the unexpected keys
"""
miss
ing_keys = []
unexpected_keys = []
error_msgs = []
# copy state_dict so _load_from_state_dict can modify it
metadata = getattr(state_dict, '_metadata', None)
state_dict = state_dict.copy()
if metadata is not None:
state_dict._metadata = metadata
def load(module, prefix=''):
local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {})
module._load_from_state_dict(
state_dict, prefix, local_metadata, True, miss
ing_keys, unexpected_keys, error_msgs)
for name, child
in module._modules.items():
if child is not None:
load(child, prefix + name + '.')
load(self)
load = None # break load->load reference cycle
if strict:
if len(unexpected_keys) > 0:
error_msgs.
insert(
0, 'Unexpected key(s)
in state_dict: {}. '.format(
', '.jo
in('"{}"'.format(k) for k
in unexpected_keys)))
if len(miss
ing_keys) > 0:
error_msgs.
insert(
0, 'Miss
ing key(s)
in state_dict: {}. '.format(
', '.jo
in('"{}"'.format(k) for k
in miss
ing_keys)))
if len(error_msgs) > 0:
raise RuntimeError('Error(s)
in load
ing state_dict for {}:\n\t{}'.format(
self.__class__.__name__, "\n\t".jo
in(error_msgs)))
return _
IncompatibleKeys(miss
ing_keys, unexpected_keys)
def _named_members(self, get_members_fn, prefix='', recurse=True):
r"""Helper method for yield
ing various names + members
of modules."""
memo = set()
modules = self.named_modules(prefix=prefix) if recurse else [(prefix, self)]
for module_prefix, module
in modules:
members = get_members_fn(module)
for k, v
in members:
if v is None or v
in memo:
cont
inue
memo.add(v)
name = module_prefix + ('.' if module_prefix else '') + k
yield name, v
def parameters(self, recurse: bool = True) -> Itera
tor[Parameter]:
r"""Returns an itera
tor over module parameters.
This is typically passed
to an optimizer.
Args:
recurse (bool): if True, then yields parameters
of this module
and all submodules. Otherwise, yields only parameters that
are direct members
of this module.
Yields:
Parameter: module parameter
Example::
>>> for param
in model.parameters():
>>> pr
int(type(param), param.size())
<class '
torch.
Tensor'> (20L,)
<class '
torch.
Tensor'> (20L, 1L, 5L, 5L)
"""
for name, param
in self.named_parameters(recurse=recurse):
yield param
def named_parameters(self, prefix: str = '', recurse: bool = True) -> Itera
tor[Tuple[str,
Tensor]]:
r"""Returns an itera
tor over module parameters, yield
ing both the
name
of the parameter as well as the parameter itself.
Args:
prefix (str): prefix
to prepend
to all parameter names.
recurse (bool): if True, then yields parameters
of this module
and all submodules. Otherwise, yields only parameters that
are direct members
of this module.
Yields:
(str
ing, Parameter): Tuple conta
ining the name and parameter
Example::
>>> for name, param
in self.named_parameters():
>>> if name
in ['bias']:
>>> pr
int(param.size())
"""
gen = self._named_members(
lambda module: module._parameters.items(),
prefix=prefix, recurse=recurse)
for elem
in gen:
yield elem
def buffers(self, recurse: bool = True) -> Itera
tor[
Tensor]:
r"""Returns an itera
tor over module buffers.
Args:
recurse (bool): if True, then yields buffers
of this module
and all submodules. Otherwise, yields only buffers that
are direct members
of this module.
Yields:
torch.
Tensor: module buffer
Example::
>>> for buf
in model.buffers():
>>> pr
int(type(buf), buf.size())
<class '
torch.
Tensor'> (20L,)
<class '
torch.
Tensor'> (20L, 1L, 5L, 5L)
"""
for name, buf
in self.named_buffers(recurse=recurse):
yield buf
def named_buffers(self, prefix: str = '', recurse: bool = True) -> Itera
tor[Tuple[str,
Tensor]]:
r"""Returns an itera
tor over module buffers, yield
ing both the
name
of the buffer as well as the buffer itself.
Args:
prefix (str): prefix
to prepend
to all buffer names.
recurse (bool): if True, then yields buffers
of this module
and all submodules. Otherwise, yields only buffers that
are direct members
of this module.
Yields:
(str
ing,
torch.
Tensor): Tuple conta
ining the name and buffer
Example::
>>> for name, buf
in self.named_buffers():
>>> if name
in ['runn
ing_var']:
>>> pr
int(buf.size())
"""
gen = self._named_members(
lambda module: module._buffers.items(),
prefix=prefix, recurse=recurse)
for elem
in gen:
yield elem
def children(self) -> Itera
tor['Module']:
r"""Returns an itera
tor over immediate children modules.
Yields:
Module: a child module
"""
for name, module
in self.named_children():
yield module
def named_children(self) -> Itera
tor[Tuple[str, 'Module']]:
r"""Returns an itera
tor over immediate children modules, yield
ing both
the name
of the module as well as the module itself.
Yields:
(str
ing, Module): Tuple conta
ining a name and child module
Example::
>>> for name, module
in model.named_children():
>>> if name
in ['conv4', 'conv5']:
>>> pr
int(module)
"""
memo = set()
for name, module
in self._modules.items():
if module is not None and module not
in memo:
memo.add(module)
yield name, module
def modules(self) -> Itera
tor['Module']:
r"""Returns an itera
tor over all modules
in the network.
Yields:
Module: a module
in the network
Note:
Duplicate modules are returned only once.
In the follow
ing
example, ``l`` will be returned only once.
Example::
>>> l = nn.L
inear(2, 2)
>>> net = nn.Sequential(l, l)
>>> for idx, m
in enumerate(net.modules()):
pr
int(idx, '->', m)
0 -> Sequential(
(0): L
inear(
in_features=2, out_features=2, bias=True)
(1): L
inear(
in_features=2, out_features=2, bias=True)
)
1 -> L
inear(
in_features=2, out_features=2, bias=True)
"""
for name, module
in self.named_modules():
yield module
def named_modules(self, memo: Optional[Set['Module']] = None, prefix: str = ''):
r"""Returns an itera
tor over all modules
in the network, yield
ing
both the name
of the module as well as the module itself.
Yields:
(str
ing, Module): Tuple
of name and module
Note:
Duplicate modules are returned only once.
In the follow
ing
example, ``l`` will be returned only once.
Example::
>>> l = nn.L
inear(2, 2)
>>> net = nn.Sequential(l, l)
>>> for idx, m
in enumerate(net.named_modules()):
pr
int(idx, '->', m)
0 -> ('', Sequential(
(0): L
inear(
in_features=2, out_features=2, bias=True)
(1): L
inear(
in_features=2, out_features=2, bias=True)
))
1 -> ('0', L
inear(
in_features=2, out_features=2, bias=True))
"""
if memo is None:
memo = set()
if self not
in memo:
memo.add(self)
yield prefix, self
for name, module
in self._modules.items():
if module is None:
cont
inue
submodule_prefix = prefix + ('.' if prefix else '') + name
for m
in module.named_modules(memo, submodule_prefix):
yield m
def tra
in(self: T, mode: bool = True) -> T:
r"""Sets the module
in tra
ining mode.
This has any effect only on certa
in modules. See documentations
of
particular modules for details
of their behaviors
in tra
ining/evaluation
mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`,
etc.
Args:
mode (bool): whether
to set tra
ining mode (``True``) or evaluation
mode (``False``). Default: ``True``.
Returns:
Module: self
"""
self.tra
ining = mode
for module
in self.children():
module.tra
in(mode)
return self
def eval(self: T) -> T:
r"""Sets the module
in evaluation mode.
This has any effect only on certa
in modules. See documentations
of
particular modules for details
of their behaviors
in tra
ining/evaluation
mode, if they are affected, e.g. :class:`Dropout`, :class:`BatchNorm`,
etc.
This is equivalent with :meth:`self.tra
in(False) <
torch.nn.Module.tra
in>`.
Returns:
Module: self
"""
return self.tra
in(False)
def requires_grad_(self: T, requires_grad: bool = True) -> T:
r"""Change if au
tograd should record operations on parameters
in this
module.
This method sets the parameters' :attr:`requires_grad` attributes
in-place.
This method is helpful for freez
ing part
of the module for f
inetun
ing
or tra
ining parts
of a model
individually (e.g., GAN tra
ining).
Args:
requires_grad (bool): whether au
tograd should record operations on
parameters
in this module. Default: ``True``.
Returns:
Module: self
"""
for p
in self.parameters():
p.requires_grad_(requires_grad)
return self
def zero_grad(self, set_
to_none: bool = False) -> None:
r"""Sets gradients
of all model parameters
to zero. See similar function
under :class:`
torch.optim.Optimizer` for more context.
Arguments:
set_
to_none (bool):
instead
of sett
ing
to zero, set the grads
to None.
See :meth:`
torch.optim.Optimizer.zero_grad` for details.
"""
if getattr(self, '_is_replica', False):
warn
ings.warn(
"Call
ing .zero_grad() from a module created with nn.DataParallel() has no effect. "
"The parameters are copied (
in a differentiable manner) from the orig
inal module. "
"This means they are not leaf nodes
in au
tograd and so don't accumulate gradients. "
"If you need gradients
in your forward method, consider us
ing au
tograd.grad
instead.")
for p
in self.parameters():
if p.grad is not None:
if set_
to_none:
p.grad = None
else:
if p.grad.grad_fn is not None:
p.grad.detach_()
else:
p.grad.requires_grad_(False)
p.grad.zero_()
def share_memory(self: T) -> T:
return self._apply(lambda t: t.share_memory_())
def _get_name(self):
return self.__class__.__name__
def extra_repr(self) -> str:
r"""Set the extra representation
of the module
To pr
int cus
tomized extra
information, you should re-implement
this method
in your own modules. Both s
ingle-l
ine and multi-l
ine
str
ings are acceptable.
"""
return ''
def __repr__(self):
# We treat the extra repr like the sub-module, one item per l
ine
extra_l
ines = []
extra_repr = self.extra_repr()
# empty str
ing will be split
into list ['']
if extra_repr:
extra_l
ines = extra_repr.split('\n')
child_l
ines = []
for key, module
in self._modules.items():
mod_str = repr(module)
mod_str = _add
indent(mod_str, 2)
child_l
ines.append('(' + key + '): ' + mod_str)
l
ines = extra_l
ines + child_l
ines
ma
in_str = self._get_name() + '('
if l
ines:
# simple one-l
iner
info, which most built
in Modules will use
if len(extra_l
ines) == 1 and not child_l
ines:
ma
in_str += extra_l
ines[0]
else:
ma
in_str += '\n ' + '\n '.jo
in(l
ines) + '\n'
ma
in_str += ')'
return ma
in_str
def __dir__(self):
module_attrs = dir(self.__class__)
attrs =
list(self.__dict__.keys())
parameters =
list(self._parameters.keys())
modules =
list(self._modules.keys())
buffers =
list(self._buffers.keys())
keys = module_attrs + attrs + parameters + modules + buffers
# Elim
inate attrs that are not legal
Python variable names
keys = [key for key
in keys if not key[0].isdigit()]
return sorted(keys)
def _replicate_for_data_parallel(self):
replica = self.__new__(type(self))
replica.__dict__ = self.__dict__.copy()
# replicas do not have parameters themselves, the replicas reference the orig
inal
# module.
replica._parameters = OrderedDict()
replica._buffers = replica._buffers.copy()
replica._modules = replica._modules.copy()
replica._is_replica = True
return replica
报错：File "D:\Anconda\envs\my_test_1\lib\site-packages\
torch\nn\modules\module.py", l
ine 1051,
in load_state_dict
raise RuntimeError('Error(s)
in load
ing state_dict for {}:\n\t{}'.format(
RuntimeError: Error(s)
in load
ing state_dict for LLFlow:
Miss
ing key(s)
in state_dict: "flowUpsamplerNet.layers.3.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.3.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.4.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.4.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.5.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.5.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.6.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.6.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.10.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.10.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.11.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.11.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.12.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.12.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.13.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.13.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.17.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.17.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.18.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.18.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.19.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.19.aff
ine.SF.resConv.2.bias", "flowUpsamplerNet.layers.20.aff
ine.SF.resConv.2.weight", "flowUpsamplerNet.layers.20.aff
ine.SF.resConv.2.bias".
Unexpected key(s)
in state_dict: "flowUpsamplerNet.layers.3.aff
ine.SF.resConv.1.weight", "flowUpsamplerNet.layers.3.aff
ine.SF.resConv.1.bias", "flowUpsamplerNet.layers.4.aff
ine.SF.resConv.1.weight", "flowUpsamplerNet.
本文记录了在使用TensorFlow实现注意力机制时遇到的错误，并提供了两种解决方案：使用tf.convert_to_tensor()将数据转换为张量，以及使用tf.pack()打包张量列表。
扫一扫
1126
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
