/usr/local/lib64/python3.6/site-packages/torch/nn/utils/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/nn/utils/__pycache__/parametrize.cpython-36.pyc (19870B)
3
Egq @ s U d dl Z d dlmZmZmZ d dlmZ d dl mZ d dlZd dl m
Z
d dl m Z m
Z
mZmZmZ d ai aeeeef e
e f e
dd Zd d
ZG d d d eZedd
ddZeeddddZddeeeeedddZd ee
e edddZ d eeeedd d Z dS ) N)
ModuleList
ModuleDictModule) Parameter)Tensor)contextmanager)UnionOptionalDictTupleSequencec c s* t d7 a z
dV W dt d8 a t s$i aX dS )a] Context manager that enables the caching system within parametrizations
registered with :func:`register_parametrization`.
The value of the parametrized objects is computed and cached the first time
they are required when this context manager is active. The cached values are
discarded when leaving the context manager.
This is useful when using a parametrized parameter more than once in the forward pass.
An example of this is when parametrizing the recurrent kernel of an RNN or when
sharing weights.
The simplest way to activate the cache is by wrapping the forward pass of the neural network
.. code-block:: python
import torch.nn.utils.parametrize as P
...
with P.cached():
output = model(inputs)
in training and evaluation. One may also wrap the parts of the modules that use
several times the parametrized tensors. For example, the loop of an RNN with a
parametrized recurrent kernel:
.. code-block:: python
with P.cached():
for x in xs:
out_rnn = self.rnn_cell(x, out_rnn)
N)_cache_enabled_cache r r F/usr/local/lib64/python3.6/site-packages/torch/nn/utils/parametrize.pycached s "
r c C s( t |tr| j|| n | j|| d S )N)
isinstancer Zregister_parameterZregister_buffer)modulenameXr r r _register_parameter_or_buffer: s
r c sb e Zd ZU dZeed
ee e
ee f edd fdd
Z edddd Z
ed
d d Z ZS )ParametrizationLista\ A sequential container that holds and manages the ``original`` or ``original0``, ``original1``, ...
parameters or buffers of a parametrized :class:`torch.nn.Module`.
It is the type of ``module.parametrizations[tensor_name]`` when ``module[tensor_name]``
has been parametrized with :func:`register_parametrization`.
If the first registered parmetrization has a ``right_inverse`` that returns one tensor or
does not have a ``right_inverse`` (in which case we assume that ``right_inverse`` is the identity),
it will hold the tensor under the name ``original``.
If it has a ``right_inverse`` that returns more than one tensor, these will be registered as
``original0``, ``original1``, ...
.. warning::
This class is used internally by :func:`register_parametrization`. It is documented
here for completeness. It shall not be instantiated by the user.
Args:
modules (sequence): sequence of modules representing the parametrizations
original (Parameter or Tensor): parameter or buffer that is parametrized
unsafe (bool): a boolean flag that denotes whether the parametrization
may change the dtype and shape of the tensor. Default: `False`
Warning: the parametrization is not checked for consistency upon registration.
Enable this flag at your own risk.
FN)modulesoriginalunsafereturnc s t |dkrtdt j| || _|j}|j}tj J |}x>t | D ]2}t
|drJy|j |}W qJ t k
rz Y qJX qJW W d Q R X t
|t rt
|tjj rtdt|j t
|t| _| jrdnt || _| jr4|j|jkrtd|j d|j tj |j| W d Q R X t| d| nrxpt|D ]d\}} t
| tsntd | d
t| j d t
|trt| } | j|j t| d| | q>W | js| }
t
|
tstd t|
j d |
j|krtd
| d|
j |
j|krtd| d|
j d S )Nr z1ParametrizationList requires one or more modules.
right_inversezT'right_inverse' must return a Tensor or a Sequence of tensors (list, tuple...). Got r
zVWhen `right_inverse` outputs one tensor, it may not change the dtype.
original.dtype: z
right_inverse(original).dtype: r z\'right_inverse' must return a Tensor or a Sequence of tensors (list, tuple...). Got element z of the sequence with type .z,A parametrization must return a tensor. Got z}Registering a parametrization may not change the dtype of the tensor, unless `unsafe` flag is enabled.
unparametrized dtype: z
parametrized dtype: z}Registering a parametrization may not change the shape of the tensor, unless `unsafe` flag is enabled.
unparametrized shape: z
parametrized shape: ) len
ValueErrorsuper__init__r shapedtypetorchno_gradreversedhasattrr NotImplementedErrorr r collectionsabcr type__name__ is_tensorntensorsset_r enumerater Zrequires_grad_
requires_grad) selfr r r Zoriginal_shapeZoriginal_dtypenewr iZ originaliZ) __class__r r r" ] sV
z ParametrizationList.__init__)valuer c C s t j v x
s z.ParametrizationList.forward..r
)r. r ranger/ r( str)r3 xZ originalsZcurr_idxr )r3 r forward s zParametrizationList.forward)F)r-
__module__ __qualname____doc__r r boolr r r r r r" r rA
__classcell__r r )r7 r r A s
e=r )r r c C s2 | j }dd }td|j |fd|i}|| _ dS )zSets up a module to be parametrized.
This works by substituting the class of the module by a class
that extends it to be able to inject a property
Args:
module (nn.Module): module into which to inject the property
c S s t dd S )NzSerialization of parametrized modules is only supported through state_dict(). See:
https://pytorch.org/tutorials/beginner/saving_loading_models.html#saving-loading-a-general-checkpoint-for-inference-and-or-resuming-training)r9 )r3 r r r getstate s z#_inject_new_class..getstateZ Parametrized __getstate__N)r7 r, r- )r clsrG Z param_clsr r r _inject_new_class s
rJ )r tensor_namer c sl t sttjjtdfdd td fdd }tddfdd }tjt|| dS )
a Injects a property into module[tensor_name].
It assumes that the class in the module has already been modified from its
original one using _inject_new_class and that the tensor under :attr:`tensor_name`
has already been moved out
Args:
module (nn.Module): module into which to inject the property
tensor_name (str): name of the name of the property to create
)r c s0 t f}tj|}|d kr,| }|t|< |S )N)idr get)parametrizationkeyr; )r rK r r get_cached_parametrization> s
z4_inject_property..get_cached_parametrizationc sN | j }trDtjj r"tdqJtjj d k r:tdqJ |S n| S d S )NzTCaching is not implemented for scripting. Either disable caching or avoid scripting.z4Cannot trace a model while caching parametrizations.)parametrizationsr r% jitZ is_scriptingr9 _CZ_get_tracing_state)r3 rN )rP rK r r get_parametrizedH s
z*_inject_property..get_parametrizedN)r8 r c s | j j| d S )N)rQ r )r3 r8 )rK r r set_originalX s z&_inject_property..set_original) r( AssertionErrorr% rR Zunusedr setattrr7 property)r rK rT rU r )rP r rK r _inject_property/ s
rY F)r )r rK rN r r c C s4 |j | j t| |r|sdt| |}||}t|tsPtdt|j d|j |j krtd| d|j d| d|j |j
|j
krtd| d|j
d| d |j
t |d
rdy|j |}W n t
k
r Y nX t|ts td t|j |j |j kr2td | d
| d|j d|j |j
|j
krdtd| d
| d|j
d|j
t| jtsvt| j| j| | j| j|O _n|| jks|| jkrt| |}t|g||d}t| | t| st| t | _t| | t| jtst|| j|< ntd| d| d| S )ai Adds a parametrization to a tensor in a module.
Assume that ``tensor_name="weight"`` for simplicity. When accessing ``module.weight``,
the module will return the parametrized version ``parametrization(module.weight)``.
If the original tensor requires a gradient, the backward pass will differentiate
through :attr:`parametrization`, and the optimizer will update the tensor accordingly.
The first time that a module registers a parametrization, this function will add an attribute
``parametrizations`` to the module of type :class:`~ParametrizationList`.
The list of parametrizations on the tensor ``weight`` will be accessible under
``module.parametrizations.weight``.
The original tensor will be accessible under
``module.parametrizations.weight.original``.
Parametrizations may be concatenated by registering several parametrizations
on the same attribute.
The training mode of a registered parametrization is updated on registration
to match the training mode of the host module
Parametrized parameters and buffers have an inbuilt caching system that can be activated
using the context manager :func:`cached`.
A :attr:`parametrization` may optionally implement a method with signature
.. code-block:: python
def right_inverse(self, X: Tensor) -> Union[Tensor, Sequence[Tensor]]
This method is called on the unparametrized tensor when the first parametrization
is registered to compute the initial value of the original tensor.
If this method is not implemented, the original tensor will be just the unparametrized tensor.
If all the parametrizations registered on a tensor implement `right_inverse` it is possible
to initialize a parametrized tensor by assigning to it, as shown in the example below.
It is possible for the first parametrization to depend on several inputs.
This may be implemented returning a tuple of tensors from ``right_inverse``
(see the example implementation of a ``RankOne`` parametrization below).
In this case, the unconstrained tensors are also located under ``module.parametrizations.weight``
with names ``original0``, ``original1``,...
.. note::
If unsafe=False (default) both the forward and right_inverse methods will be called
once to perform a number of consistency checks.
If unsafe=True, then right_inverse will be called if the tensor is not parametrized,
and nothing will be called otherwise.
.. note::
In most situations, ``right_inverse`` will be a function such that
``forward(right_inverse(X)) == X`` (see
`right inverse `_).
Sometimes, when the parametrization is not surjective, it may be reasonable
to relax this.
.. warning::
If a parametrization depends on several inputs, :func:`~register_parametrization`
will register a number of new parameters. If such parametrization is registered
after the optimizer is created, these new parameters will need to be added manually
to the optimizer. See :meth:`torch.Optimizer.add_param_group`.
Args:
module (nn.Module): module on which to register the parametrization
tensor_name (str): name of the parameter or buffer on which to register
the parametrization
parametrization (nn.Module): the parametrization to register
Keyword args:
unsafe (bool): a boolean flag that denotes whether the parametrization
may change the dtype and shape of the tensor. Default: `False`
Warning: the parametrization is not checked for consistency upon registration.
Enable this flag at your own risk.
Raises:
ValueError: if the module does not have a parameter or a buffer named :attr:`tensor_name`
Examples:
>>> import torch
>>> import torch.nn as nn
>>> import torch.nn.utils.parametrize as P
>>>
>>> class Symmetric(nn.Module):
>>> def forward(self, X):
>>> return X.triu() + X.triu(1).T # Return a symmetric matrix
>>>
>>> def right_inverse(self, A):
>>> return A.triu()
>>>
>>> m = nn.Linear(5, 5)
>>> P.register_parametrization(m, "weight", Symmetric())
>>> print(torch.allclose(m.weight, m.weight.T)) # m.weight is now symmetric
True
>>> A = torch.rand(5, 5)
>>> A = A + A.T # A is now symmetric
>>> m.weight = A # Initialize the weight to be the symmetric matrix A
>>> print(torch.allclose(m.weight, A))
True
>>> class RankOne(nn.Module):
>>> def forward(self, x, y):
>>> # Form a rank 1 matrix multiplying two vectors
>>> return x.unsqueeze(-1) @ y.unsqueeze(-2)
>>>
>>> def right_inverse(self, Z):
>>> # Project Z onto the rank 1 matrices
>>> U, S, Vh = torch.linalg.svd(Z, full_matrices=False)
>>> # Return rescaled singular vectors
>>> s0_sqrt = S[0].sqrt().unsqueeze(-1)
>>> return U[..., :, 0] * s0_sqrt, Vh[..., 0, :] * s0_sqrt
>>>
>>> linear_rank_one = P.register_parametrization(nn.Linear(4, 4), "weight", RankOne())
>>> print(torch.linalg.matrix_rank(linear_rank_one.weight).item())
1
z,A parametrization must return a tensor. Got r zrRegistering a parametrization may not change the dtype of the tensor, unless the `unsafe` flag is enabled.
module.z.dtype: z
parametrization(module.z ).dtype: zrRegistering a parametrization may not change the shape of the tensor, unless the `unsafe` flag is enabled.
module.z.shape: z ).shape: r z9parametrization.right_inverse must return a tensor. Got: zXThe tensor returned by parametrization.right_inverse must have the same dtype as module.z., unless the `unsafe` flag is enabled.
module.z
returned dtype: zXThe tensor returned by parametrization.right_inverse must have the same shape as module.z
returned shape: )r zModule 'zL' does not have a parameter, a buffer, or a parametrized element with name '')ZtrainZtrainingis_parametrizedr: r r r r, r- r$ r# r( r r) rQ r rV appendr Z_buffers _parametersr delattrrJ rY ) r rK rN r Yr r6 r rQ r r r register_parametrization] sX {
" " ""
r` c C sD t | dd}|dks t|t r$dS |dkr8t|dkS ||kS dS )aJ Returns ``True`` if module has an active parametrization.
If the argument :attr:`tensor_name` is specified, returns ``True`` if
``module[tensor_name]`` is parametrized.
Args:
module (nn.Module): module to query
name (str, optional): attribute in the module to query
Default: ``None``
rQ NFr )r: r r r )r rK rQ r r r r[ , s r[ T)r rK leave_parametrizedr c C s t | |s td| d| t| jts.t| j| }|jr|j}|rtj t
| |}W dQ R X tj |j | W dQ R X n*|rt
| |}|j rt
|n|}ntdt| j| | j|= t| || t | st| d | jjd }|| _| S )a Removes the parametrizations on a tensor in a module.
- If ``leave_parametrized=True``, ``module[tensor_name]`` will be set to
its current output. In this case, the parametrization shall not change the ``dtype``
of the tensor.
- If ``leave_parametrized=False``, ``module[tensor_name]`` will be set to
the unparametrised tensor in ``module.parametrizations[tensor_name].original``.
This is only possible when the parametrization depends on just one tensor.
Args:
module (nn.Module): module from which remove the parametrization
tensor_name (str): name of the parametrization to be removed
leave_parametrized (bool, optional): leave the attribute :attr:`tensor_name` parametrized.
Default: ``True``
Returns:
Module: module
Raises:
ValueError: if ``module[tensor_name]`` is not parametrized
ValueError: if ``leave_parametrized=False`` and the parametrization depends on several tensors
zModule z$ does not have a parametrization on NzyCannot leave unparametrized (`leave_parametrized=False`) a tensor that is parametrized in terms of a sequence of tensors.rQ r )r[ r r rQ r rV r. r r% r& r: r0 r2 r r^ r7 r __bases__)r rK ra rQ r tZorig_clsr r r remove_parametrizationsA s.
rd )N)T) r% Ztorch.nn.modules.containerr r r Ztorch.nn.parameterr r r*
contextlibr typingr r r
r r r r intr? r r r rJ rY rE r` r[ rd r r r r s* + Q / N