U “PÓh<ã@sRdZddlmZddlZddlmZddlmZddlm Z ddl mZddlm Z mZmZdd d ddd ddgZGdd„de ƒZdd„ZedddZedddZedddZedddZedddZedddZe d¡d d!d"œd#d$„ƒZe d%e j¡e d&¡d d'd"œd(d)„ƒZe d*¡d d+d"œd,d-„ƒZe d.¡d/d0„ƒZe d1e j ¡e d2e j!¡e d3e j"¡e d4e j#¡e d5e j$j%¡e d6e j$j&¡e d7e j$j'¡e d8e j$j(¡e d9e j$j)¡e d:e j$j*¡e d;e j$j+¡e de j$j.¡e d?e j$j/¡e d@e j$j0¡e dA¡dBdC„ƒZ1e dD¡dEdF„ƒZ2e dG¡dHdI„ƒZ3e dJ¡dKdL„ƒZ4e dM¡d dNd"œdOdP„ƒZ5e dQ¡d dRd"œdSdT„ƒZ6e dU¡d dVd"œdWdX„ƒZ7e dY¡d dZd"œd[d\„ƒZ8e d]¡d d^d"œd_d`„ƒZ9e da¡d dbd"œdcdd„ƒZ:e de¡d dfd"œdgdh„ƒZ;e di¡d djd"œdkdl„ƒZhóz0LayerFactory.add_factory_class..)N©r*)rrr,r!rr/rÚadd_factory_classdszLayerFactory.add_factory_class)rrcsdddœ‡‡fdd„}|S)zN Decorator for adding a factory function with the given name. r)r rcsˆ ˆ|¡|Sr-r2)r ©rrrrÚ_addosz+LayerFactory.factory_function.._addr)rrr5rr4rÚfactory_functionjszLayerFactory.factory_functionr)Úfactory_namercGs:t|tƒs tdt|ƒj›dƒ‚t| ¡|jƒ}|j|ŽS)z Get the constructor for the given factory name and arguments. Raises: TypeError: When ``factory_name`` is not a ``str``. zfactory_name must a str but is Ú.) Ú isinstancerÚ TypeErrorr+Ú__name__rr&Ú componentsÚvalue)rr7ÚargsÚ componentrrrÚget_constructorus zLayerFactory.get_constructor)rcCs:t|ƒr|St|tƒr"|d}}n|^}}|j|f|žŽS)zí Get the given name or name/arguments pair. If `args` is a callable it is assumed to be the constructor itself and is returned, otherwise it should be the factory name or a pair containing the name and arguments. r)Úcallabler9rr@)rr>Úname_objrrrÚ__getitem__…s zLayerFactory.__getitem__cs||jkr|Stƒ |¡S)zÞ If `key` is a factory name, return it, otherwise behave as inherited. This allows referring to factory names as if they were constants, eg. `Fact.FOO` for a factory Fact with factory function foo. )r<rÚ__getattribute__)rÚkeyrrrÚ__getattr__—s zLayerFactory.__getattr__)N)N)r;Ú __module__Ú__qualname__rrr*r3r6r@rCrFÚ __classcell__rrrrr Ls cCsJt|tƒr|ifS|\}}t|tƒs,t|ƒr6t|tƒsBd}t|ƒ‚||fS)a¾ Split arguments in a way to be suitable for using with the factory types. If `args` is a string it's interpreted as the type name. Args: args (str or a tuple of object name and kwarg dict): input arguments to be parsed. Raises: TypeError: When ``args`` type is not in ``Union[str, Tuple[Union[str, Callable], dict]]``. Examples:: >>> act_type, args = split_args("PRELU") >>> monai.networks.layers.Act[act_type] >>> act_type, args = split_args(("PRELU", {"num_parameters": 1, "init": 0.25})) >>> monai.networks.layers.Act[act_type](**args) PReLU(num_parameters=1) z_Layer specifiers must be single strings or pairs of the form (name/object-types, argument dict))r9rrAÚdictr:)r>rBZ name_argsÚmsgrrrr£s zDropout layersz$Factory for creating dropout layers.)rrzNormalization layersz*Factory for creating normalization layers.zActivation layersz'Factory for creating activation layers.zConvolution layersz(Factory for creating convolution layers.zPooling layersz$Factory for creating pooling layers.zPadding layersz$Factory for creating padding layers.ÚdropoutÚintz.type[nn.Dropout | nn.Dropout2d | nn.Dropout3d])ÚdimrcCstjtjtjf}||dS)z Dropout layers in 1,2,3 dimensions. Args: dim: desired dimension of the dropout layer Returns: Dropout[dim]d r#)Únnr Ú Dropout2dÚ Dropout3d©rNÚtypesrrrÚdropout_factoryÎsrTZalphadropoutÚinstancez?type[nn.InstanceNorm1d | nn.InstanceNorm2d | nn.InstanceNorm3d]cCstjtjtjf}||dS)z³ Instance normalization layers in 1,2,3 dimensions. Args: dim: desired dimension of the instance normalization layer Returns: InstanceNorm[dim]d r#)rOÚInstanceNorm1dÚInstanceNorm2dÚInstanceNorm3drRrrrÚinstance_factoryàsrYÚbatchz6type[nn.BatchNorm1d | nn.BatchNorm2d | nn.BatchNorm3d]cCstjtjtjf}||dS)zª Batch normalization layers in 1,2,3 dimensions. Args: dim: desired dimension of the batch normalization layer Returns: BatchNorm[dim]d r#)rOÚBatchNorm1dÚBatchNorm2dÚBatchNorm3drRrrrÚ batch_factoryïsr^Zinstance_nvfusercCs`|dkr:tjtjf}t d||d›d¡||dStƒsPt d¡tjStdddd S) aŸ `InstanceNorm3dNVFuser` is a faster version of InstanceNorm layer and implemented in `apex`. It only supports 3d tensors as the input. It also requires to use with CUDA and non-Windows OS. In this function, if the required library `apex.normalization.InstanceNorm3dNVFuser` does not exist, `nn.InstanceNorm3d` will be returned instead. This layer is based on a customized autograd function, which is not supported in TorchScript currently. Please switch to use `nn.InstanceNorm3d` if TorchScript is necessary. Please check the following link for more details about how to install `apex`: https://github.com/NVIDIA/apex#installation éz4`InstanceNorm3dNVFuser` only supports 3d cases, use r#z instead.zd`apex.normalization.InstanceNorm3dNVFuser` is not installed properly, use nn.InstanceNorm3d instead.zapex.normalizationÚInstanceNorm3dNVFuser)rr)rOrVrWÚwarningsÚwarnrrXrrRrrrÚinstance_nvfuser_factoryþsÿrcÚgroupÚlayerZ localresponseZ syncbatchÚeluÚreluZ leakyreluÚpreluÚrelu6ÚseluÚceluÚgeluÚsigmoidÚtanhÚsoftmaxZ logsoftmaxZswishcCsddlm}|S)z= Swish activation layer. Returns: Swish r©ÚSwish)Ú monai.networks.blocks.activationrqrprrrÚ swish_factory-srsZmemswishcCsddlm}|S)z] Memory efficient swish activation layer. Returns: MemoryEfficientSwish r©ÚMemoryEfficientSwish)rrrurtrrrÚmemswish_factory:srvÚmishcCsddlm}|S)z; Mish activation layer. Returns: Mish r©ÚMish)rrryrxrrrÚmish_factoryGsrzZgeglucCsddlm}|S)z= GEGLU activation layer. Returns: GEGLU r©ÚGEGLU)rrr|r{rrrÚ geglu_factoryTsr}Úconvz'type[nn.Conv1d | nn.Conv2d | nn.Conv3d]cCstjtjtjf}||dS)z™ Convolutional layers in 1,2,3 dimensions. Args: dim: desired dimension of the convolutional layer Returns: Conv[dim]d r#)rOÚConv1dÚConv2dÚConv3drRrrrÚconv_factoryasr‚Z convtranszBtype[nn.ConvTranspose1d | nn.ConvTranspose2d | nn.ConvTranspose3d]cCstjtjtjf}||dS)z¸ Transposed convolutional layers in 1,2,3 dimensions. Args: dim: desired dimension of the transposed convolutional layer Returns: ConvTranspose[dim]d r#)rOÚConvTranspose1dÚConvTranspose2dÚConvTranspose3drRrrrÚconvtrans_factorypsr†Úmaxz0type[nn.MaxPool1d | nn.MaxPool2d | nn.MaxPool3d]cCstjtjtjf}||dS)z˜ Max pooling layers in 1,2,3 dimensions. Args: dim: desired dimension of the max pooling layer Returns: MaxPool[dim]d r#)rOÚ MaxPool1dÚ MaxPool2dÚ MaxPool3drRrrrÚmaxpooling_factorysr‹ZadaptivemaxzHtype[nn.AdaptiveMaxPool1d | nn.AdaptiveMaxPool2d | nn.AdaptiveMaxPool3d]cCstjtjtjf}||dS)z² Adaptive max pooling layers in 1,2,3 dimensions. Args: dim: desired dimension of the adaptive max pooling layer Returns: AdaptiveMaxPool[dim]d r#)rOÚAdaptiveMaxPool1dÚAdaptiveMaxPool2dÚAdaptiveMaxPool3drRrrrÚadaptive_maxpooling_factoryŽsrÚavgz0type[nn.AvgPool1d | nn.AvgPool2d | nn.AvgPool3d]cCstjtjtjf}||dS)z Average pooling layers in 1,2,3 dimensions. Args: dim: desired dimension of the average pooling layer Returns: AvgPool[dim]d r#)rOÚ AvgPool1dÚ AvgPool2dÚ AvgPool3drRrrrÚavgpooling_factorysr”ZadaptiveavgzHtype[nn.AdaptiveAvgPool1d | nn.AdaptiveAvgPool2d | nn.AdaptiveAvgPool3d]cCstjtjtjf}||dS)zº Adaptive average pooling layers in 1,2,3 dimensions. Args: dim: desired dimension of the adaptive average pooling layer Returns: AdaptiveAvgPool[dim]d r#)rOÚAdaptiveAvgPool1dÚAdaptiveAvgPool2dÚAdaptiveAvgPool3drRrrrÚadaptive_avgpooling_factory¬sr˜ZreplicationpadzEtype[nn.ReplicationPad1d | nn.ReplicationPad2d | nn.ReplicationPad3d]cCstjtjtjf}||dS)z¯ Replication padding layers in 1,2,3 dimensions. Args: dim: desired dimension of the replication padding layer Returns: ReplicationPad[dim]d r#)rOÚReplicationPad1dÚReplicationPad2dÚReplicationPad3drRrrrÚreplication_pad_factory»srœZconstantpadzs‚3W#