j8pddlZddlmZddlmZmZmZddlmZ ddl m Z dZ dZ dZGdd e ZGd d eZGd d eZGddeZGddeZGddeZGddeZGddeZGddeZGddeZdS)N) accumulate)OptionalTupleUnion)Modulect|ttfr1t||krt |t|St|t st ||g|zS)N) isinstancelisttuplelen ValueErrorint)xnmsgs _/lsinfo/ai/hellotax_ai/base_platform/venv/lib/python3.11/site-packages/mlx/nn/layers/pooling.py_value_or_listr sg!dE]## q66Q;;S// !Aww a  oo 37Nc|dg}t|dd|D]2\}}|||z||3||dt|dz }dgtd|dtd|d|}||}||}|S)Nr)zipappendr rangereshape transpose)rshape window_shape new_shapesw last_axis axis_orders r _non_overlapping_sliding_windowsr%sq IE!""I|,,1a    U2YI"IQeAy!,,QuQ 1/E/EQyQJ )A JA Hrc |jdkrtd|jd|jdd}t|t|cxkrt|ksBntdt|dt|dt|d |j}t d t |||Drt |||Sttttt|d ztj dd}|d g}|d t |||Dz }||z }||dgz }|dd}|dt |dd|Dz }||ddz }||ddz }tj |||S)NzcTo extract sliding windows at least 1 spatial dimension (3 total) is needed but the input only has z dimensions.rrzTo extract sliding windows the window shapes and strides must have the same number of spatial dimensions as the signal but the signal has z dims and the window shape has z and strides have .c3<K|]\}}}||ko||zdkVdSrN.0sizewindowstrides r z#_sliding_windows..8sO   D&& &/TF]a/      rrrc,g|]\}}}||z |zdzSr2r+r,s r z$_sliding_windows..Bs< D&& 6!A%rcg|] \}}||z Sr+r+)r- og_strider0s rr4z$_sliding_windows..Ks.0y& Fr)ndimr rr allrr%r reversedroperatormulmx as_strided)rrwindow_strides spatial_dimsrstrides final_shape final_stridess r_sliding_windowsrC'sVvzz O:;& O O O   71R4=L   \!2!2 I I I Ic.6I6I I I I I 7|$$ 7 7EHEVEV 7 7!$N 3 3 7 7 7    GE   $' lN$S$S   H05,GGG8DHUT\,B,BHL!Q!QRRSSTTUVUWUWXG8*K$' lN$S$SK<KE"I;KBQBKM47" ~4V4VMWQrT]"MWRSS\!M =K 7 77rc*eZdZfdZdZdZxZS)_Poolct||_||_||_||_||_ttt|j dz dd|_ dS)Nrr) super__init___pooling_function _kernel_size_stride_padding_padding_valuer rr _axes)selfpooling_function kernel_sizer0padding padding_value __class__s rrHz_Pool.__init__Usq !1'  +5#d&7"8"8!81!.bs&//A1Q4//////rz kernel_size=z , stride=z , padding=)r rJrKrL)rOksstpds r _extra_reprz_Pool._extra_repr_s] 4$ % % 4<  ///// / /=b==2=====rctd|jDr)tj|dg|jzdgz|j}t ||j|j}|||j S)Nc3.K|]}|ddkVdSr*r+rWs rr1z!_Pool.__call__..gs*//Aqtax//////r)rr)constant_values) anyrLr<padrMrCrJrKrIrN)rOrs r__call__z_Pool.__call__fs ///// / / 4=(F83 $ 3A Q 14< @ @%%a444r)__name__ __module__ __qualname__rHr\rb __classcell__rTs@rrErETs[FFFFF>>>5555555rrEc eZdZ ddeeeefdeeeeefdeeeefffd ZxZS)_Pool1dNrrQr0rRc~t|j}d}t|d||d}|&t|d||d}n|}t|d||d}d|D}t |||||dS)Nz<[{}] '{}' must be an integer or a tuple containing 1 integerrrQr0rRcg|]}||fSr+r+rWs rr4z$_Pool1d.__init__..+++aAq6+++rtypercrformatrGrH rOrPrSrQr0rR class_namerrTs rrHz_Pool1d.__init__rs$ZZ( L$ CJJz=AA    #FAszz*h/O/OPPFF F !SZZ I-N-NOO++7+++ );WWWWWrNr rcrdrerrrrrHrfrgs@rririqs 48*+ XX3c ?+ X sE#J/0 X sE#J' XXXXXXXXXXrric eZdZ ddeeeeeffdeeeeeeffdeeeeeeffffd ZxZS)_Pool2dNrrQr0rRc~t|j}d}t|d||d}|&t|d||d}n|}t|d||d}d|D}t |||||dS)Nz=[{}] '{}' must be an integer or a tuple containing 2 integersrrQr0rRcg|]}||fSr+r+rWs rr4z$_Pool2d.__init__..rlrrmrps rrHz_Pool2d.__init__$ZZ( M$ CJJz=AA    #FAszz*h/O/OPPFF F !SZZ I-N-NOO++7+++ );WWWWWrrrrsrgs@rrurus 9=9: XX3c3h/0 X sE#s(O345 X %U38_ 456 XXXXXXXXXXrruc eZdZ ddeeeeeeffdeeeeeeeffdeeeeeeeffffd ZxZS)_Pool3dNrrQr0rRc~t|j}d}t|d||d}|&t|d||d}n|}t|d||d}d|D}t |||||dS)Nz=[{}] '{}' must be an integer or a tuple containing 3 integersr'rQr0rRcg|]}||fSr+r+rWs rr4z$_Pool3d.__init__..rlrrmrps rrHz_Pool3d.__init__rxrrrrsrgs@rrzrzs >B>? XX3c3m 445 X sE#sC-$889: X %U3S=%9 9:; XXXXXXXXXXrrzc eZdZdZ ddeeeefdeeeeefdeeeefffd ZxZ S) MaxPool1da,Applies 1-dimensional max pooling. Spatially downsamples the input by taking the maximum of a sliding window of size ``kernel_size`` and sliding stride ``stride``. Args: kernel_size (int or tuple(int)): The size of the pooling window kernel. stride (int or tuple(int), optional): The stride of the pooling window. Default: ``kernel_size``. padding (int or tuple(int), optional): How much negative infinity padding to apply to the input. The padding amount is applied to both sides of the spatial axis. Default: ``0``. Examples: >>> import mlx.core as mx >>> import mlx.nn.layers as nn >>> x = mx.random.normal(shape=(4, 16, 5)) >>> pool = nn.MaxPool1d(kernel_size=2, stride=2) >>> pool(x) NrrQr0rRcttjt d |||dSNinfrGrHr<maxfloatrOrQr0rRrTs rrHzMaxPool1d.__init__5 %,, VWMMMMMrrr rcrdre__doc__rrrrrHrfrgs@rr~r~s048*+ NN3c ?+NsE#J/0NsE#J' NNNNNNNNNNrr~c eZdZdZ ddeeeefdeeeeefdeeeefffd ZxZ S) AvgPool1da#Applies 1-dimensional average pooling. Spatially downsamples the input by taking the average of a sliding window of size ``kernel_size`` and sliding stride ``stride``. Args: kernel_size (int or tuple(int)): The size of the pooling window kernel. stride (int or tuple(int), optional): The stride of the pooling window. Default: ``kernel_size``. padding (int or tuple(int), optional): How much zero padding to apply to the input. The padding amount is applied to both sides of the spatial axis. Default: ``0``. Examples: >>> import mlx.core as mx >>> import mlx.nn.layers as nn >>> x = mx.random.normal(shape=(4, 16, 5)) >>> pool = nn.AvgPool1d(kernel_size=2, stride=2) >>> pool(x) NrrQr0rRcfttjd|||dSrrrGrHr<meanrs rrHzAvgPool1d.__init__- ![&'BBBBBrrrrrgs@rrrs048*+ CC3c ?+CsE#J/0CsE#J' CCCCCCCCCCrrc eZdZdZ ddeeeeeffdeeeeeeffdeeeeeeffffd ZxZ S) MaxPool2daApplies 2-dimensional max pooling. Spatially downsamples the input by taking the maximum of a sliding window of size ``kernel_size`` and sliding stride ``stride``. The parameters ``kernel_size``, ``stride``, and ``padding`` can either be: * a single ``int`` -- in which case the same value is used for both the height and width axis. * a ``tuple`` of two ``int`` s -- in which case, the first ``int`` is used for the height axis, the second ``int`` for the width axis. Args: kernel_size (int or tuple(int, int)): The size of the pooling window. stride (int or tuple(int, int), optional): The stride of the pooling window. Default: ``kernel_size``. padding (int or tuple(int, int), optional): How much negative infinity padding to apply to the input. The padding is applied on both sides of the height and width axis. Default: ``0``. Examples: >>> import mlx.core as mx >>> import mlx.nn.layers as nn >>> x = mx.random.normal(shape=(8, 32, 32, 4)) >>> pool = nn.MaxPool2d(kernel_size=2, stride=2) >>> pool(x) NrrQr0rRcttjt d |||dSrrrs rrHzMaxPool2d.__init__rrrrrrgs@rrrs>9=9: NN3c3h/0NsE#s(O345N%U38_ 456 NNNNNNNNNNrrc eZdZdZ ddeeeeeffdeeeeeeffdeeeeeeffffd ZxZ S) AvgPool2da|Applies 2-dimensional average pooling. Spatially downsamples the input by taking the average of a sliding window of size ``kernel_size`` and sliding stride ``stride``. The parameters ``kernel_size``, ``stride``, and ``padding`` can either be: * a single ``int`` -- in which case the same value is used for both the height and width axis. * a ``tuple`` of two ``int`` s -- in which case, the first ``int`` is used for the height axis, the second ``int`` for the width axis. Args: kernel_size (int or tuple(int, int)): The size of the pooling window. stride (int or tuple(int, int), optional): The stride of the pooling window. Default: ``kernel_size``. padding (int or tuple(int, int), optional): How much zero padding to apply to the input. The padding is applied on both sides of the height and width axis. Default: ``0``. Examples: >>> import mlx.core as mx >>> import mlx.nn.layers as nn >>> x = mx.random.normal(shape=(8, 32, 32, 4)) >>> pool = nn.AvgPool2d(kernel_size=2, stride=2) >>> pool(x) NrrQr0rRcfttjd|||dSrrrrs rrHzAvgPool2d.__init__:rrrrrrgs@rrrs>9=9: CC3c3h/0CsE#s(O345C%U38_ 456 CCCCCCCCCCrrc eZdZdZ ddeeeeeeffdeeeeeeeffdeeeeeeeffffd ZxZ S) MaxPool3daApplies 3-dimensional max pooling. Spatially downsamples the input by taking the maximum of a sliding window of size ``kernel_size`` and sliding stride ``stride``. The parameters ``kernel_size``, ``stride``, and ``padding`` can either be: * a single ``int`` -- in which case the same value is used for the depth, height, and width axis. * a ``tuple`` of three ``int`` s -- in which case, the first ``int`` is used for the depth axis, the second ``int`` for the height axis, and the third ``int`` for the width axis. Args: kernel_size (int or tuple(int, int, int)): The size of the pooling window. stride (int or tuple(int, int, int), optional): The stride of the pooling window. Default: ``kernel_size``. padding (int or tuple(int, int, int), optional): How much negative infinity padding to apply to the input. The padding is applied on both sides of the depth, height and width axis. Default: ``0``. Examples: >>> import mlx.core as mx >>> import mlx.nn.layers as nn >>> x = mx.random.normal(shape=(8, 16, 32, 32, 4)) >>> pool = nn.MaxPool3d(kernel_size=2, stride=2) >>> pool(x) NrrQr0rRcttjt d |||dSrrrs rrHzMaxPool3d.__init__arrrrrrgs@rrrCs@>B>? NN3c3m 445NsE#sC-$889:N%U3S=%9 9:; NNNNNNNNNNrrc eZdZdZ ddeeeeeeffdeeeeeeeffdeeeeeeeffffd ZxZ S) AvgPool3daApplies 3-dimensional average pooling. Spatially downsamples the input by taking the average of a sliding window of size ``kernel_size`` and sliding stride ``stride``. The parameters ``kernel_size``, ``stride``, and ``padding`` can either be: * a single ``int`` -- in which case the same value is used for the depth, height, and width axis. * a ``tuple`` of three ``int`` s -- in which case, the first ``int`` is used for the depth axis, the second ``int`` for the height axis, and the third ``int`` for the width axis. Args: kernel_size (int or tuple(int, int, int)): The size of the pooling window. stride (int or tuple(int, int, int), optional): The stride of the pooling window. Default: ``kernel_size``. padding (int or tuple(int, int, int), optional): How much zero padding to apply to the input. The padding is applied on both sides of the depth, height and width axis. Default: ``0``. Examples: >>> import mlx.core as mx >>> import mlx.nn.layers as nn >>> x = mx.random.normal(shape=(8, 16, 32, 32, 4)) >>> pool = nn.AvgPool3d(kernel_size=2, stride=2) >>> pool(x) NrrQr0rRcfttjd|||dSrrrrs rrHzAvgPool3d.__init__rrrrrrgs@rrrjs@>B>? CC3c3m 445CsE#sC-$889:C%U3S=%9 9:; CCCCCCCCCCrr)r: itertoolsrtypingrrrmlx.corecorer<mlx.nn.layers.baserrr%rCrErirurzr~rrrrrr+rrrs ))))))))))%%%%%%       *8*8*8Z55555F555:XXXXXeXXX0XXXXXeXXX0XXXXXeXXX0NNNNNNNN>CCCCCCCC>#N#N#N#N#N#N#N#NL#C#C#C#C#C#C#C#CL$N$N$N$N$N$N$N$NN$C$C$C$C$C$C$C$C$C$Cr