o h@s ddlZddlmZmZddlmZmZmZddl m Z m Z ddl m Z mZmZmZmZddlmZmZddlZddlmZddlmZd d lmZgd Zed ed ZddZededGdddeZ GdddeZ!GdddeZ"GdddeZ#GdddeZ$GdddeZ%dS)N)abc OrderedDict)IterableIteratorMapping)chainislice)AnyOptionaloverloadTypeVarUnion) deprecatedSelf)_copy_to_script_wrapper) Parameter)Module) Container Sequential ModuleList ModuleDict ParameterList ParameterDictT)boundcsP|d}t|dkr |S|d}fdd|D}d|}|d|}|S)N rrcsg|]}d|qS) ).0line numSpacesrn/var/www/html/construction_image-detection-poc/venv/lib/python3.10/site-packages/torch/nn/modules/container.py $z_addindent..)splitlenpopjoin)s_r"sfirstrr!r# _addindents     r-zq`nn.Container` is deprecated. All of it's functionality is now implemented in `nn.Module`. Subclass that instead.)categorycs&eZdZdeddffdd ZZS)rkwargsreturnNc s,t|D] \}}|||q dSN)super__init__items add_module)selfr/keyvalue __class__rr#r30s zContainer.__init__)__name__ __module__ __qualname__r r3 __classcell__rrr9r#r*srcseZdZUdZeeefed<ededdfddZ ed3d dZ fd dZ de fd d Z e de eefde de ffddZdededdfddZde eefddfddZe defddZd4ddZde eefdefddZdefddZdeddfd d!Zdeddfd"d#Zdedefd$d%Ze fd&d'Ze deefd(d)Zd*d+Zdeddfd,d-Zd.ededdfd/d0Z d4d1d2Z!Z"S)5raA 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()) ])) _modulesargsr0NcGdSr1r)r6r@rrr#r3fzSequential.__init__argOrderedDict[str, Module]cCrAr1r)r6rCrrr#r3jrBcsptt|dkr%t|dtr%|dD] \}}|||qdSt|D] \}}|t||q)dS)Nrr) r2r3r' isinstancerr4r5 enumeratestr)r6r@r7moduleidxr9rr#r3ns cCsRt|}t|}| |kr|ksntd|d||;}tt||dS)z$Get the idx-th item of the iterator.index  is out of rangeN)r'operatorindex IndexErrornextr)r6iteratorrIsizerrr#_get_item_by_idxws  zSequential._get_item_by_idxrIcCs8t|tr|tt|j|S||j|Sr1) rEslicer:rlistr?r4rRvaluesr6rIrrr# __getitem__s zSequential.__getitem__rHcCs||j|}t|||Sr1)rRr?keyssetattr)r6rIrHr7rrr# __setitem__s zSequential.__setitem__cCst|trt|j|D]}t||qn||j|}t||ddtt|jD}t tt ||j |_dS)NcSg|]}t|qSrrGrirrr#r$z*Sequential.__delitem__..) rErSrTr?rXdelattrrRranger'rziprU)r6rIr7 str_indicesrrr# __delitem__s   zSequential.__delitem__cC t|jSr1r'r?r6rrr#__len__ zSequential.__len__cCsTt|trt}|D]}||q |D]}||q|Stdtt|dNz.r2__dir__r6rXr9rr#r zSequential.__dir__cCt|jSr1iterr?rUrgrrr#__iter__zSequential.__iter__cCs|D]}||}q|Sr1r)r6inputrHrrr#forward zSequential.forwardcC|tt|||S)zjAppend a given module to the end. Args: module (nn.Module): module to append r5rGr'r6rHrrr#rkzSequential.appendrMcCst|ts tdtt|j}| |kr|ks$ntd||dkr,||7}t||dD]}|jt|d|jt|<q2||jt|<|S)Nzmodule should be of type: zIndex out of range: rr)rErAssertionErrorr'r?rNrarG)r6rMrHnr^rrr#inserts  zSequential.insertcCs|D]}||q|Sr1)rk)r6 sequentialrprrr#extend s zSequential.extend)rCrDr0N)r0r)#r;r<r=__doc__dictrGr__annotations__r r3rrRrr rSryrWrZrdrhrqr(rrwr}rrrrrrrkrrr>rrr9r#r6s: -    $     rcseZdZUdZeeefed<d+dee eddffdd Z dd Z e d e ddfd d Ze d edefd d Zed eee fdeedffdd Zd ededdfddZd eee fddfddZedefddZedeefddZde edefddZde eddfddZddZefdd Zd!ededdfd"d#Zdeddfd$d%Zd&eee fdefd'd(Zde edefd)d*ZZ S),raHolds 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) -> None: super().__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 r?Nmodulesr0cs"t|dur||7}dSdSr1)r2r3r6rr9rr#r3)s  zModuleList.__init__cCVt|}t| |krt|ksntd|d|dkr'|t|7}t|Sz/Get the absolute index for the list of modules.rJrKrrLrMr'rNrGrVrrr#_get_abs_string_index.   z ModuleList._get_abs_string_indexrIcCrAr1rrVrrr#rW7rBzModuleList.__getitem__cCrAr1rrVrrr#rW;rBcCs2t|tr|t|j|S|j||Sr1)rErSr:rTr?rUrrVrrr#rW?s rHcCs||}t|t||Sr1)rrYrG)r6rIrHrrr#rZFs zModuleList.__setitem__cCsxt|trtt|j|D] }t|t|qnt|||ddtt|jD}tt t ||j |_dS)NcSr[rr\r]rrr#r$Qr_z*ModuleList.__delitem__..) rErSrar'r?r`rGrrrTrbrU)r6rIkrcrrr#rdJs zModuleList.__delitem__cCrer1rfrgrrr#rhTrizModuleList.__len__cCrr1rrgrrr#rXrzModuleList.__iter__cCr~r1rrrrr#rw\rzModuleList.__iadd__rncCs2t}tt||D] \}}|t||q |Sr1)rrFrr5rG)r6rnr{r^rHrrr#rq_szModuleList.__add__c Cs.dd|D}t|dkr|dSddgg}|dg}t|dddD]!\}}||dkr;|ddd7<q&|||g||q&g}|d}t||D]0\\}} } d|d | } || kr{| |d} d|d | d | d | } t| d } || qU|d d |d7}|d7}|S)zTReturn a custom repr for ModuleList that compresses repeated module representations.cSr[r)repr)ritemrrr#r$gr_z'ModuleList.__repr__..rz()rNr(): -z x z r))r' _get_namerFrkrbr-r)) r6 list_of_reprsstart_end_indicesrepeated_blocksr^rlinesmain_strstart_idend_idb local_reprrrrr#__repr__es.          zModuleList.__repr__cr)NcSrrrrrrr#r$r%z&ModuleList.__dir__..rrr9rr#rrzModuleList.__dir__rMcCsFtt|j|dD]}|jt|d|jt|<q ||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 rrN)rar'r?rG)r6rMrHr^rrr#rszModuleList.insertcCr)zvAppend a given module to the end of the list. Args: module (nn.Module): module to append rrrrr#rkrzModuleList.appendr7cCrrr1rrsrrr#r(ruzModuleList.popcCsPt|tjstdt|jt|}t|D]\}}|t |||q|S)zAppend 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 ) rEcontainer_abcsrrzrmr;r'rFr5rG)r6rrvr^rHrrr#rs zModuleList.extendr1)!r;r<r=rrrGrrr rr3rr rSrWryrr rZrdrhrrrrwrqrrrrkr(rr>rrr9r#rs4   $    rcsFeZdZUdZeeefed<d"dee eefddffdd Z e dedefd d Z ded eddfd d Z deddfddZe defddZe deefddZe dedefddZd#ddZdedefddZe deefddZe deeeeffddZe deefddZde eefddfd d!ZZS)$ra,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) -> None: super().__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 r?Nrr0cs$t|dur||dSdSr1)r2r3updaterr9rr#r3s zModuleDict.__init__r7cCs |j|Sr1r?r6r7rrr#rWrizModuleDict.__getitem__rHcCs|||dSr1)r5)r6r7rHrrr#rZszModuleDict.__setitem__cCs |j|=dSr1rrrrr#rds zModuleDict.__delitem__cCrer1rfrgrrr#rhrizModuleDict.__len__cCrer1)rr?rgrrr#rrizModuleDict.__iter__cC ||jvSr1rrrrr# __contains__rizModuleDict.__contains__cCs|jdS)z%Remove all items from the ModuleDict.N)r?clearrgrrr#rrzModuleDict.clearcCrr)zRemove key from the ModuleDict and return its module. Args: key (str): key to pop from the ModuleDict rrsrrr#r(zModuleDict.popcC |jS)z*Return an iterable of the ModuleDict keys.)r?rXrgrrr#rX zModuleDict.keyscCr)z5Return an iterable of the ModuleDict key/value pairs.)r?r4rgrrr#r4rzModuleDict.itemscCr)z,Return an iterable of the ModuleDict values.)r?rUrgrrr#rUrzModuleDict.valuescCst|tjstdt|jt|tttjfr'| D]\}}|||<qd St |D]9\}}t|tjsDtdt |dt|jt |dks\t dt |dt t |d|d||d<q+d S) aUpdate the :class:`~torch.nn.ModuleDict` with key-value pairs from a mapping, 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 # should be Iterable; isr has length ; 2 is requiredrrN)rErrrzrmr;rrrr4rFrGr'rl)r6rr7rHjmrrr#rsF     zModuleDict.updater1r0N)r;r<r=rrrGrrr rr3rrWrZrdryrhrrboolrrr(rrXtupler4rUrr>rrr9r#rs. +$  "rcs eZdZdZd$deeeddffdd ZddZe d e defd d Z e d e d e de fd d Z dd Z d e deddfddZde fddZdeefddZdeedefddZfddZdeddfddZdeedefddZdefd d!Zd"d#ZZS)%ra>Holds parameters in a list. :class:`~torch.nn.ParameterList` can be used like a regular Python list, but Tensors that are :class:`~torch.nn.Parameter` are properly registered, and will be visible by all :class:`~torch.nn.Module` methods. Note that the constructor, assigning an element of the list, the :meth:`~torch.nn.ParameterList.append` method and the :meth:`~torch.nn.ParameterList.extend` method will convert any :class:`~torch.Tensor` into :class:`~torch.nn.Parameter`. Args: parameters (iterable, optional): an iterable of elements to add to the list. Example:: class MyModule(nn.Module): def __init__(self) -> None: super().__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 NrUr0cs(td|_|dur||7}dSdS)Nr)r2r3_size)r6rUr9rr#r3as  zParameterList.__init__cCrrrrVrrr#rgrz#ParameterList._get_abs_string_indexrIcCrAr1rrVrrr#rWprBzParameterList.__getitem__r6cCrAr1rrVrrr#rWtrBcCsbt|tr%|t|\}}}|}t|||D] }|||q|S||}t|t |Sr1) rErSindicesr'r:rarkrgetattrrG)r6rIstartstopstepoutr^rrr#rWxs  paramcCs8||}t|tjrt|tst|}t|t||Sr1)rrEtorchTensorrrYrG)r6rIrrrr#rZs zParameterList.__setitem__cCs|jSr1)rrgrrr#rhszParameterList.__len__cstfddttDS)Nc3|]}|VqdSr1rr]rgrr# z)ParameterList.__iter__..)rrar'rgrrgr#rszParameterList.__iter__ parameterscCr~r1rr6rrrr#rwrzParameterList.__iadd__cr)NcSrrrrrrr#r$r%z)ParameterList.__dir__..rrr9rr#rs zParameterList.__dir__r8cCs"t|}|jd7_|||<|S)zmAppend a given value at the end of the list. Args: value (Any): value to append r)r'r)r6r8new_idxrrr#rkszParameterList.appendcCsBt|tjr t|tjrtdt|j|D]}||q|S)zAppend values from a Python iterable to the end of the list. Args: values (iterable): iterable of values to append z@ParameterList.extend should be called with an iterable, but got ) rErrrrrzrmr;rk)r6rUr8rrr#rs zParameterList.extendcCsg}t|D]Y\}}t|tjrOddd|D}|jjdtj fvr/d|jd}nd}d t|t r:d nd |j ||}| d t|d |q| d t|d t|jqd|}|S)Nxcs|]}t|VqdSr1r\rrQrrr#rrz+ParameterList.extra_repr..cuda (r {} containing: [{} of size {}{}]rr (r): Object of type: r)rFrErrr)rQdevicerm_C_get_privateuse1_backend_nameformatrdtyperkrGr;r6 child_linesrpsize_str device_strparastrtmpstrrrr# extra_reprs&  zParameterList.extra_reprcOtd)Nz#ParameterList should not be called. RuntimeError)r6r@r/rrr#__call__zParameterList.__call__r1)r;r<r=rr rr r3rr ryrWrrSrZrhrrrrwrrkrrGrrr>rrr9r#rEs$      rcseZdZdZdddZdedefd d!Zdeeeffd"d#Zd None: super().__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 Nrr0cs*ti|_|dur||dSdSr1)r2r3_keysrrr9rr#r3s zParameterDict.__init__r7cCs$t|tstdt|jd|S)NzUIndex given to ParameterDict cannot be used as a key as it is not a string (type is 'z8'). Open an issue on github if you need non-string keys.)rErGrzrmr;rrrr# _key_to_attrs zParameterDict._key_to_attrcCs||}t||Sr1)rrr6r7attrrrr#rW s  zParameterDict.__getitem__r8cCsBd|j|<||}t|tjrt|tst|}t|||dSr1)rrrErrrrY)r6r7r8rrrr#rZs  zParameterDict.__setitem__cCs |j|=||}t||dSr1)rrr`rrrr#rds zParameterDict.__delitem__cCrer1)r'rrgrrr#rh rzParameterDict.__len__cCrer1)rrrgrrr#r#rzParameterDict.__iter__cCstt|jSr1)reversedrTrrgrrr# __reversed__&szParameterDict.__reversed__csttfddjDS)z@Return a copy of this :class:`~torch.nn.ParameterDict` instance.c3|] }||fVqdSr1rrrrgrr#r-z%ParameterDict.copy..)rrrrgrrgr#copy)szParameterDict.copycCrr1rrrrr#r/rzParameterDict.__contains__defaultcCs||vr|||<||S)a\Set the default for a key in the Parameterdict. If key is in the ParameterDict, return its value. If not, insert `key` with a parameter `default` and return `default`. `default` defaults to `None`. Args: key (str): key to set default for default (Any): the parameter set to the key rr6r7rrrr# setdefault2s zParameterDict.setdefaultcCs|jD]}||=qdS)z(Remove all items from the ParameterDict.N)rr)r6rrrr#rAszParameterDict.clearcCrr)zRemove key from the ParameterDict and return its parameter. Args: key (str): key to pop from the ParameterDict rrsrrr#r(FrzParameterDict.popcCs.|j\}}d|j|<||}||=||fS)zSRemove and return the last inserted `(key, parameter)` pair from the ParameterDict.N)rpopitem)r6rr|valrrr#r Ps  zParameterDict.popitemcCs||vr||S|S)aReturn the parameter associated with key if present. Otherwise return default if provided, None if not. Args: key (str): key to get from the ParameterDict default (Parameter, optional): value to return if key not present rrrrr#getYszParameterDict.getrXcstfdd|DS)zReturn a new ParameterDict with the keys provided. Args: keys (iterable, string): keys to make the new ParameterDict from default (Parameter, optional): value to set for all keys c3s|]}|fVqdSr1rrrrr#rkrz)ParameterDict.fromkeys..)r)r6rXrrr r#fromkeysbs zParameterDict.fromkeyscCr)z-Return an iterable of the ParameterDict keys.)rrXrgrrr#rXmrizParameterDict.keyscfddjDS)z8Return an iterable of the ParameterDict key/value pairs.c3rr1rrrgrr#rsrz&ParameterDict.items..rrgrrgr#r4qzParameterDict.itemscr)z/Return an iterable of the ParameterDict values.c3rr1rrrgrr#rwrz'ParameterDict.values..rrgrrgr#rUurzParameterDict.valuescCst|tjstdt|jt|ttfr%|D]\}}|||<qd St|tj r.rrrrrrrrrrr)r4rErrr)rQrrmrrrrtypenamerkrGr;rrrr#rs&  zParameterDict.extra_reprcCr)Nz#ParameterDict should not be called.r)r6rrrr#rrzParameterDict.__call__rncCs|}|||Sr1rrr6rnrrrr#__or__rzParameterDict.__or__cCs|}|||Sr1rrrrr#__ror__rzParameterDict.__ror__cCs|||Sr1)rrrrr#__ior__s zParameterDict.__ior__r1)r0rr)rnrr0r))r;r<r=rr r3rGrrWrZrdryrhrrrrrrr rrr(rr r rr rXr4rUr rrrrrrrrr>rrr9r#rsD$         "'  r)&rL collectionsrrrcollections.abcrrr itertoolsrrtypingr r r r r typing_extensionsrrrtorch._jit_internalrtorch.nn.parameterrrHr__all__rr- FutureWarningrrrrrrrrrr#s6     Z)