/usr/local/lib64/python3.6/site-packages/torch/nn/modules/__pycache__
Edit: /usr/local/lib64/python3.6/site-packages/torch/nn/modules/__pycache__/container.cpython-36.pyc (27970B)
3
Egf @ s d dl Z d dlmZmZ d dlmZ d dlZd dlZddl m
Z
d dl m Z d dl
mZmZmZmZmZmZmZmZmZmZmZ erd dlmZ ed e
d
ZG d d d e
Z G d
d de
Z G dd de
Z G dd de
Z G dd de
Z G dd de
Z!dS ) N) OrderedDictabc)islice )Module)_copy_to_script_wrapper) AnyDictIterableIteratorMappingOptional
TYPE_CHECKINGoverloadTupleTypeVarUnion) ParameterT)boundc s$ e Zd Zedd fdd Z ZS ) ContainerN)kwargsreturnc s> t t| j tjd x |j D ]\}}| j|| q"W d S )Nzmnn.Container is deprecated. All of it's functionality is now implemented in nn.Module. Subclass that instead.)superr __init__warningswarnitems
add_module)selfr keyvalue) __class__ F/usr/local/lib64/python3.6/site-packages/torch/nn/modules/container.pyr s
zContainer.__init__)__name__
__module__ __qualname__r r
__classcell__r# r# )r" r$ r s r c s e Zd ZU dZeeef eeddddZ edddddZ fd dZ e
d
d d Z e e
d e
f d
d
dZeeddddZe
eef ddddZe ed
ddZe fddZe ee d
ddZdd Z ZS )
Sequentiala A sequential container.
Modules will be added to it in the order they are passed in the
constructor. Alternatively, an ``OrderedDict`` of modules can be
passed in. The ``forward()`` method of ``Sequential`` accepts any
input and forwards it to the first module it contains. It then
"chains" outputs to inputs sequentially for each subsequent module,
finally returning the output of the last module.
The value a ``Sequential`` provides over manually calling a sequence
of modules is that it allows treating the whole container as a
single module, such that performing a transformation on the
``Sequential`` applies to each of the modules it stores (which are
each a registered submodule of the ``Sequential``).
What's the difference between a ``Sequential`` and a
:class:`torch.nn.ModuleList`? A ``ModuleList`` is exactly what it
sounds like--a list for storing ``Module`` s! On the other hand,
the layers in a ``Sequential`` are connected in a cascading way.
Example::
# Using Sequential to create a small model. When `model` is run,
# input will first be passed to `Conv2d(1,20,5)`. The output of
# `Conv2d(1,20,5)` will be used as the input to the first
# `ReLU`; the output of the first `ReLU` will become the input
# for `Conv2d(20,64,5)`. Finally, the output of
# `Conv2d(20,64,5)` will be used as input to the second `ReLU`
model = nn.Sequential(
nn.Conv2d(1,20,5),
nn.ReLU(),
nn.Conv2d(20,64,5),
nn.ReLU()
)
# Using Sequential with OrderedDict. This is functionally the
# same as the above code
model = nn.Sequential(OrderedDict([
('conv1', nn.Conv2d(1,20,5)),
('relu1', nn.ReLU()),
('conv2', nn.Conv2d(20,64,5)),
('relu2', nn.ReLU())
]))
N)argsr c G s d S )Nr# )r r* r# r# r$ r L s zSequential.__init__zOrderedDict[str, Module])argr c C s d S )Nr# )r r+ r# r# r$ r P s c sz t t| j t|dkrPt|d trPxL|d j D ]\}}| j|| q6W n&x$t|D ]\}}| jt || qZW d S )Nr r )
r r) r len
isinstancer r r enumeratestr)r r* r moduleidx)r" r# r$ r T s )r c C sR t | }tj|}| | ko&|k n s:tdj|||; }tt||dS )z#Get the idx-th item of the iteratorzindex {} is out of rangeN)r, operatorindex
IndexErrorformatnextr )r iteratorr1 sizer# r# r$ _get_item_by_idx] s
zSequential._get_item_by_idxc C s< t |tr&| jtt| jj | S | j| jj |S d S )N) r- slicer" r list_modulesr r9 values)r r1 r# r# r$ __getitem__f s
zSequential.__getitem__)r1 r0 r c C s | j | jj |}t| ||S )N)r9 r< keyssetattr)r r1 r0 r r# r# r$ __setitem__m s zSequential.__setitem__)r1 r c C sR t |tr2xBt| jj | D ]}t| | q W n | j| jj |}t| | d S )N)r- r: r; r< r? delattrr9 )r r1 r r# r# r$ __delitem__q s
zSequential.__delitem__c C s
t | jS )N)r, r< )r r# r# r$ __len__y s zSequential.__len__c s t t| j }dd |D }|S )Nc S s g | ]}|j s|qS r# )isdigit).0r r# r# r$
s z&Sequential.__dir__..)r r) __dir__)r r? )r" r# r$ rH } s zSequential.__dir__c C s t | jj S )N)iterr< r= )r r# r# r$ __iter__ s zSequential.__iter__c C s x| D ] }||}qW |S )Nr# )r inputr0 r# r# r$ forward s
zSequential.forward)r% r& r' __doc__r r/ r r< r r r r9 r r r> intrA r: rC rD rH r rJ rL r( r# r# )r" r$ r) s$
+ r) c s e Zd ZU dZeeef d!ee e dd fdd
Z
dd Z e e
edd d
Ze
edd d d
Zee
ef ddddZe e
dddZe ee dddZe e d dddZe fddZe
eddddZed d d d Ze e d dd d Z ZS )"
ModuleLista Holds submodules in a list.
:class:`~torch.nn.ModuleList` can be indexed like a regular Python list, but
modules it contains are properly registered, and will be visible by all
:class:`~torch.nn.Module` methods.
Args:
modules (iterable, optional): an iterable of modules to add
Example::
class MyModule(nn.Module):
def __init__(self):
super(MyModule, self).__init__()
self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(10)])
def forward(self, x):
# ModuleList can act as an iterable, or be indexed using ints
for i, l in enumerate(self.linears):
x = self.linears[i // 2](x) + l(x)
return x
N)modulesr c s" t t| j |d k r | |7 } d S )N)r rO r )r rP )r" r# r$ r s zModuleList.__init__c C sV t j|}t| | ko&t| k n s:tdj||dk rN|t| 7 }t|S )z.Get the absolute index for the list of moduleszindex {} is out of ranger )r2 r3 r, r4 r5 r/ )r r1 r# r# r$ _get_abs_string_index s
" z ModuleList._get_abs_string_index)r1 r c C s6 t |tr"| jt| jj | S | j| j| S d S )N)r- r: r" r; r< r= rQ )r r1 r# r# r$ r> s
zModuleList.__getitem__)r1 r0 r c C s | j |}t| t||S )N)rQ r@ r/ )r r1 r0 r# r# r$ rA s
zModuleList.__setitem__c C s| t |tr6x:tt| j| D ]}t| t| q W nt| | j| dd tt| jD }tt t
|| jj | _d S )Nc S s g | ] }t |qS r# )r/ )rF ir# r# r$ rG s z*ModuleList.__delitem__..) r- r: ranger, r< rB r/ rQ r r; zipr= )r r1 kZ str_indicesr# r# r$ rC s
zModuleList.__delitem__)r c C s
t | jS )N)r, r< )r r# r# r$ rD s zModuleList.__len__c C s t | jj S )N)rI r< r= )r r# r# r$ rJ s zModuleList.__iter__c C s
| j |S )N)extend)r rP r# r# r$ __iadd__ s zModuleList.__iadd__c s t t| j }dd |D }|S )Nc S s g | ]}|j s|qS r# )rE )rF r r# r# r$ rG s z&ModuleList.__dir__..)r rO rH )r r? )r" r# r$ rH s zModuleList.__dir__)r3 r0 r c C sJ x6t t| j|dD ] }| jt|d | jt|< qW || jt|< dS )zInsert a given module before a given index in the list.
Args:
index (int): index to insert.
module (nn.Module): module to insert
r N)rS r, r< r/ )r r3 r0 rR r# r# r$ insert s zModuleList.insert)r0 r c C s | j tt| | | S )zwAppends a given module to the end of the list.
Args:
module (nn.Module): module to append
)r r/ r, )r r0 r# r# r$ append s zModuleList.appendc C sT t |tjs tdt|j t| }x(t|D ] \}}| jt || | q0W | S )zAppends modules from a Python iterable to the end of the list.
Args:
modules (iterable): iterable of modules to append
z=ModuleList.extend should be called with an iterable, but got )
r- container_abcsr
TypeErrortyper% r, r. r r/ )r rP offsetrR r0 r# r# r$ rV s zModuleList.extend)N) r% r& r' rM r r/ r r< r
r
r rQ r rN r> rA r r: rC rD r rJ rW rH rY rZ rV r( r# r# )r" r$ rO s"
rO c s6 e Zd ZU dZeeef d!ee eef dd fdd
Z
e eedddZ eedd d
d Z
eddd d
Ze edddZe ee dddZe eedddZddddZeedddZe ee dddZe eeeef ddd Ze ee dd d Ze eef ddd d Z Z S )"
ModuleDicta2 Holds submodules in a dictionary.
:class:`~torch.nn.ModuleDict` can be indexed like a regular Python dictionary,
but modules it contains are properly registered, and will be visible by all
:class:`~torch.nn.Module` methods.
:class:`~torch.nn.ModuleDict` is an **ordered** dictionary that respects
* the order of insertion, and
* in :meth:`~torch.nn.ModuleDict.update`, the order of the merged
``OrderedDict``, ``dict`` (started from Python 3.6) or another
:class:`~torch.nn.ModuleDict` (the argument to
:meth:`~torch.nn.ModuleDict.update`).
Note that :meth:`~torch.nn.ModuleDict.update` with other unordered mapping
types (e.g., Python's plain ``dict`` before Python version 3.6) does not
preserve the order of the merged mapping.
Args:
modules (iterable, optional): a mapping (dictionary) of (string: module)
or an iterable of key-value pairs of type (string, module)
Example::
class MyModule(nn.Module):
def __init__(self):
super(MyModule, self).__init__()
self.choices = nn.ModuleDict({
'conv': nn.Conv2d(10, 10, 3),
'pool': nn.MaxPool2d(3)
})
self.activations = nn.ModuleDict([
['lrelu', nn.LeakyReLU()],
['prelu', nn.PReLU()]
])
def forward(self, x, choice, act):
x = self.choices[choice](x)
x = self.activations[act](x)
return x
N)rP r c s$ t t| j |d k r | j| d S )N)r r_ r update)r rP )r" r# r$ r 2 s zModuleDict.__init__)r r c C s
| j | S )N)r< )r r r# r# r$ r> 7 s zModuleDict.__getitem__)r r0 r c C s | j || d S )N)r )r r r0 r# r# r$ rA ; s zModuleDict.__setitem__c C s | j |= d S )N)r< )r r r# r# r$ rC > s zModuleDict.__delitem__)r c C s
t | jS )N)r, r< )r r# r# r$ rD A s zModuleDict.__len__c C s
t | jS )N)rI r< )r r# r# r$ rJ E s zModuleDict.__iter__c C s
|| j kS )N)r< )r r r# r# r$ __contains__I s zModuleDict.__contains__c C s | j j dS )z.Remove all items from the ModuleDict.
N)r< clear)r r# r# r$ rb M s zModuleDict.clearc C s | | }| |= |S )zRemove key from the ModuleDict and return its module.
Args:
key (string): key to pop from the ModuleDict
r# )r r vr# r# r$ popR s zModuleDict.popc C s
| j j S )z3Return an iterable of the ModuleDict keys.
)r< r? )r r# r# r$ r? \ s zModuleDict.keysc C s
| j j S )z>Return an iterable of the ModuleDict key/value pairs.
)r< r )r r# r# r$ r b s zModuleDict.itemsc C s
| j j S )z5Return an iterable of the ModuleDict values.
)r< r= )r r# r# r$ r= h s zModuleDict.valuesc C s t |tjs tdt|j t |tttjfrPx|j D ]\}}|| |< q:W nx~t
|D ]r\}}t |tjstdt | d t|j t |dkst
dt | d t t | d |d | |d < qZW d S )
a! Update the :class:`~torch.nn.ModuleDict` with the key-value pairs from a
mapping or an iterable, overwriting existing keys.
.. note::
If :attr:`modules` is an ``OrderedDict``, a :class:`~torch.nn.ModuleDict`, or
an iterable of key-value pairs, the order of new elements in it is preserved.
Args:
modules (iterable): a mapping (dictionary) from string to :class:`~torch.nn.Module`,
or an iterable of key-value pairs of type (string, :class:`~torch.nn.Module`)
zPModuleDict.update should be called with an iterable of key/value pairs, but got z$ModuleDict update sequence element #z should be Iterable; is z has length z; 2 is requiredr r N)r- r[ r
r\ r] r% r r_ r r r. r/ r,
ValueError)r rP r r0 jmr# r# r$ r` n s zModuleDict.update)N) r% r& r' rM r r/ r r< r
r r r r> rA rC rN rD r rJ boolra rb rd r
r? r r r= r` r( r# r# )r" r$ r_ s,
* "
r_ c s4 e Zd ZU dZeedf d+eed dd fdd
Z fddZ
d d
Z e e
dd d d
Ze eeeddd
Zdd
Ze
dddddZeedd fdd Ze
dddZed dddZed d dd d Z fd d Zdd d d!d"Zed d dd#d$Zedd%d&Zd'd( Z fd)d*Z Z S ),
ParameterLista: Holds parameters in a list.
:class:`~torch.nn.ParameterList` can be indexed like a regular Python
list, but parameters it contains are properly registered, and will be
visible by all :class:`~torch.nn.Module` methods.
Args:
parameters (iterable, optional): an iterable of :class:`~torch.nn.Parameter` to add
Example::
class MyModule(nn.Module):
def __init__(self):
super(MyModule, self).__init__()
self.params = nn.ParameterList([nn.Parameter(torch.randn(10, 10)) for i in range(10)])
def forward(self, x):
# ParameterList can act as an iterable, or be indexed using ints
for i, p in enumerate(self.params):
x = self.params[i // 2].mm(x) + p.mm(x)
return x
r N)
parametersr c s( t t| j d| _|d k r$| |7 } d S )NT)r rj r _initialized)r rk )r" r# r$ r s zParameterList.__init__c s" d|d< t t| j| d| _d S )NFrl T)r rj __setstate__rl )r state)r" r# r$ rm s zParameterList.__setstate__c C sV t j|}t| | ko&t| k n s:tdj||dk rN|t| 7 }t|S )z.Get the absolute index for the list of moduleszindex {} is out of ranger )r2 r3 r, r4 r5 r/ )r r1 r# r# r$ rQ s
" z#ParameterList._get_abs_string_index)r1 r c C s d S )Nr# )r r1 r# r# r$ r> s zParameterList.__getitem__)r r1 r c C s d S )Nr# )r r1 r# r# r$ r> s c C s> t |tr"| jt| jj | S | j|}| jt| S d S )N)r- r: r" r; _parametersr= rQ r/ )r r1 r# r# r$ r> s
)r1 paramr c C s | j |}| jt||S )N)rQ register_parameterr/ )r r1 rp r# r# r$ rA s
zParameterList.__setitem__)r r! r c sH t | ddr2t| | r2t|tjj r2tjd tt | j
|| d S )Nrl Fz5Setting attributes on ParameterList is not supported.) getattrhasattrr- torchnnr r r r rj __setattr__)r r r! )r" r# r$ rv s
zParameterList.__setattr__)r c C s
t | jS )N)r, ro )r r# r# r$ rD s zParameterList.__len__c C s t | jj S )N)rI ro r= )r r# r# r$ rJ s zParameterList.__iter__c C s
| j |S )N)rV )r rk r# r# r$ rW s zParameterList.__iadd__c s t t| j }dd |D }|S )Nc S s g | ]}|j s|qS r# )rE )rF r r# r# r$ rG s z)ParameterList.__dir__..)r rj rH )r r? )r" r# r$ rH s zParameterList.__dir__) parameterr c C s | j tt| | | S )zAppends a given parameter at the end of the list.
Args:
parameter (nn.Parameter): parameter to append
)rq r/ r, )r rw r# r# r$ rZ s zParameterList.appendc C sT t |tjs tdt|j t| }x(t|D ] \}}| jt || | q0W | S )zAppends parameters from a Python iterable to the end of the list.
Args:
parameters (iterable): iterable of parameters to append
z@ParameterList.extend should be called with an iterable, but got )
r- r[ r
r\ r] r% r, r. rq r/ )r rk r^ rR rp r# r# r$ rV s zParameterList.extendc C s g }xt| j j D ]f\}}djdd |j D }|js:dn dj|j }djtj|||}|j dt
| d | qW d j|}|S )
Nxc s s | ]}t |V qd S )N)r/ )rF r8 r# r# r$ s z+ParameterList.extra_repr.. z (GPU {})z'Parameter containing: [{} of size {}{}]z (z):
) ro r joinr8 is_cudar5
get_devicert typenamerZ r/ )r child_linesrU psize_str
device_strparastrtmpstrr# r# r$
extra_repr s
zParameterList.extra_reprc C s t dd S )Nz#ParameterList should not be called.) RuntimeError)r rK r# r# r$ __call__ s zParameterList.__call__c s t jd tt| j S )Nznn.ParameterList is being used with DataParallel but this is not supported. This list will appear empty for the models replicated on each GPU except the original one.)r r r rj _replicate_for_data_parallel)r )r" r# r$ r s
z*ParameterList._replicate_for_data_parallel)N) r% r& r' rM r r/ ro r
r
r rm rQ r rN r> r r: rA r rv rD r rJ rW rH rZ rV r r r r( r# r# )r" r$ rj s*
rj c s^ e Zd ZU dZeedf d-eeedf dd fdd
Z fddZ
edd d
d Z eddd d
dZ edd ddZ
eedd fdd ZedddZee dddZeed ddZdddd Zedd d d Zee dd d Zeeedf dd!d"Zed dd#d$Z eedf ddd%d&Z edd'd(Z d)d* Z fd+d,Z Z!S ).
ParameterDicta^ Holds parameters in a dictionary.
ParameterDict can be indexed like a regular Python dictionary, but parameters it
contains are properly registered, and will be visible by all Module methods.
:class:`~torch.nn.ParameterDict` is an **ordered** dictionary that respects
* the order of insertion, and
* in :meth:`~torch.nn.ParameterDict.update`, the order of the merged ``OrderedDict``
or another :class:`~torch.nn.ParameterDict` (the argument to
:meth:`~torch.nn.ParameterDict.update`).
Note that :meth:`~torch.nn.ParameterDict.update` with other unordered mapping
types (e.g., Python's plain ``dict``) does not preserve the order of the
merged mapping.
Args:
parameters (iterable, optional): a mapping (dictionary) of
(string : :class:`~torch.nn.Parameter`) or an iterable of key-value pairs
of type (string, :class:`~torch.nn.Parameter`)
Example::
class MyModule(nn.Module):
def __init__(self):
super(MyModule, self).__init__()
self.params = nn.ParameterDict({
'left': nn.Parameter(torch.randn(5, 10)),
'right': nn.Parameter(torch.randn(5, 10))
})
def forward(self, x, choice):
x = self.params[choice].mm(x)
return x
r N)rk r c s* t t| j d| _|d k r&| j| d S )NT)r r r rl r` )r rk )r" r# r$ r > s zParameterDict.__init__c s" d|d< t t| j| d| _d S )NFrl T)r r rm rl )r rn )r" r# r$ rm D s zParameterDict.__setstate__)r r c C s
| j | S )N)ro )r r r# r# r$ r> I s zParameterDict.__getitem__)r rw r c C s | j || d S )N)rq )r r rw r# r# r$ rA L s zParameterDict.__setitem__c C s | j |= d S )N)ro )r r r# r# r$ rC O s zParameterDict.__delitem__)r r! r c sH t | ddr2t| | r2t|tjj r2tjd tt | j
|| d S )Nrl Fz5Setting attributes on ParameterDict is not supported.) rr rs r- rt ru r r r r r rv )r r r! )r" r# r$ rv R s
zParameterDict.__setattr__)r c C s
t | jS )N)r, ro )r r# r# r$ rD X s zParameterDict.__len__c C s t | jj S )N)rI ro r? )r r# r# r$ rJ [ s zParameterDict.__iter__c C s
|| j kS )N)ro )r r r# r# r$ ra ^ s zParameterDict.__contains__c C s | j j dS )z1Remove all items from the ParameterDict.
N)ro rb )r r# r# r$ rb a s zParameterDict.clearc C s | | }| |= |S )zRemove key from the ParameterDict and return its parameter.
Args:
key (string): key to pop from the ParameterDict
r# )r r rc r# r# r$ rd f s zParameterDict.popc C s
| j j S )z6Return an iterable of the ParameterDict keys.
)ro r? )r r# r# r$ r? p s zParameterDict.keysc C s
| j j S )zAReturn an iterable of the ParameterDict key/value pairs.
)ro r )r r# r# r$ r u s zParameterDict.itemsc C s
| j j S )z8Return an iterable of the ParameterDict values.
)ro r= )r r# r# r$ r= z s zParameterDict.valuesc C s t |tjs tdt|j t |ttfrLx|j D ]\}}|| |< q6W nt |tj r|xt
|j D ]\}}|| |< qfW nx~t |D ]r\}}t |tjstdt | d t|j t
|dkstdt | d t t
| d |d | |d < qW d S )
aC Update the :class:`~torch.nn.ParameterDict` with the key-value pairs from a
mapping or an iterable, overwriting existing keys.
.. note::
If :attr:`parameters` is an ``OrderedDict``, a :class:`~torch.nn.ParameterDict`, or
an iterable of key-value pairs, the order of new elements in it is preserved.
Args:
parameters (iterable): a mapping (dictionary) from string to
:class:`~torch.nn.Parameter`, or an iterable of
key-value pairs of type (string, :class:`~torch.nn.Parameter`)
zTParametersDict.update should be called with an iterable of key/value pairs, but got z'ParameterDict update sequence element #z should be Iterable; isre z has length z; 2 is requiredr r N)r- r[ r
r\ r] r% r r r r sortedr. r/ r, rf )r rk r rw rg r r# r# r$ r` s&
zParameterDict.updatec C s g }xp| j j D ]b\}}djdd |j D }|js:dn dj|j }djtj|||}|j d| d | qW d j|}|S )
Nrx c s s | ]}t |V qd S )N)r/ )rF r8 r# r# r$ ry s z+ParameterDict.extra_repr..rz z (GPU {})z'Parameter containing: [{} of size {}{}]z (z): r{ )
ro r r| r8 r} r5 r~ rt r rZ )r r rU r r r r r r# r# r$ r s
zParameterDict.extra_reprc C s t dd S )Nz#ParameterDict should not be called.)r )r rK r# r# r$ r s zParameterDict.__call__c s t jd tt| j S )Nznn.ParameterDict is being used with DataParallel but this is not supported. This dict will appear empty for the models replicated on each GPU except the original one.)r r r r r )r )r" r# r$ r s
z*ParameterDict._replicate_for_data_parallel)N)"r% r& r' rM r r/ ro r
r r rm r> rA rC r rv rN rD r rJ ri ra rb rd r
r? r r r= r` r r r r( r# r# )r" r$ r s(
$ "
% r )"r collectionsr r r[ itertoolsr r2 rt r0 r Ztorch._jit_internalr typingr r r
r r r
r r r r r Ztorch.nnr r r r) rO r_ rj r r# r# r# r$ s$ 4 ts