GJj82ddlZddlmZddlmZmZmZddlmZ ddl m Z dZ dZ dZGdd e ZGd d eZGd d eZGddeZGddeZGddeZGddeZGddeZGddeZGddeZy)N) accumulate)OptionalTupleUnion)Modulect|ttfr$t||k7r t |t|St|t s t ||g|zS)N) isinstancelisttuplelen ValueErrorint)xnmsgs _/Users/ahmed/devFolder/claude-voice/.venv/lib/python3.12/site-packages/mlx/nn/layers/pooling.py_value_or_listr sM!dE]# q6Q;S/ !Aw a o 37NcP|dg}t|dd|D]*\}}|j||z|j|,|j|dt|dz }dgtd|dtd|d|}|j |}|j |}|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/EQyQJ )A JA Hrc \|jdkrtd|jd|jdd}t|t|cxk(rt|k(s2ntdt|dt|dt|d |j}t d t |||Dr t |||Sttttt|d ztjdd}|d g}|t |||D cgc]\}}} ||z | zdzc} }}z }||z }||dgz }|dd} | t |dd|D cgc] \} } | | z c} } z } | |ddz } | |ddz } tj||| Scc} }}wcc} } w) 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 .c3BK|]\}}}||k(xr||zdk(ywrN).0sizewindowstrides r z#_sliding_windows..8s5 $S D&& &/TF]a//$Ss)rr)ndimr rr allrr%r reversedroperatormulmx as_strided) rrwindow_strides spatial_dimsrstrides final_shaper-r.r/ final_strides og_strides r_sliding_windowsr>'svvz::;&& O  771R=L  \!2 Ic.6I I|$%%DSEVDWX #N 34A 7   GGE  $' lN$S 05,GG8DHUT\,BHLL!QRSTUVUWXG8*K$' lN$S$S D&& 6!A%$SK<KE"I;KBQKM47" ~4V4V0y& F4VMWQr]"MWRS\!M ==K 77s "F! %F(c*eZdZfdZdZdZxZS)_Poolct|||_||_||_||_||_ttt|j dz dd|_ y)Nrr) super__init___pooling_function _kernel_size_stride_padding_padding_valuer rr _axes)selfpooling_function kernel_sizer/padding padding_value __class__s rrCz_Pool.__init__Us\ !1'  +5#d&7&7"8!81!.bs/A1Q4sz kernel_size=z , stride=z , padding=)r rErFrG)rJksstpds r _extra_reprz_Pool._extra_repr_sM 4$$ % 4<<  // /bT2$j==rctd|jDr4tj|dg|jzdgz|j}t ||j |j}|j||jS)Nc3,K|] }|ddkDywr*r+rRs rr0z!_Pool.__call__..gs/Aqtaxs)rr)constant_values) anyrGr6padrHr>rErFrDrI)rJrs r__call__z_Pool.__call__fst // /4==(F83 $ 3 3A Q 1 14<< @%%a44r)__name__ __module__ __qualname__rCrWr] __classcell__rOs@rr@r@TsF>5rr@c heZdZ ddeeeefdeeeeefdeeeefffd ZxZS)_Pool1drLr/rMc>t|j}d}t|d|j|d}|t|d|j|d}n|}t|d|j|d}|Dcgc]}||f}}t ||||||ycc}w)Nz<[{}] '{}' must be an integer or a tuple containing 1 integerrrLr/rMtyper^rformatrBrC rJrKrNrLr/rM class_namerrSrOs rrCz_Pool1d.__init__rs$Z(( L$ CJJz=A   #FAszz*h/OPF F !SZZ I-NO#*+7aAq67+ );W,9 BNr r^r_r`rrrrrCrarbs@rrdrdqsd 48*+ X3c ?+ X sE#J/0 X sE#J' XXrrdc zeZdZ ddeeeeeffdeeeeeeffdeeeeeeffffd ZxZS)_Pool2drLr/rMc>t|j}d}t|d|j|d}|t|d|j|d}n|}t|d|j|d}|Dcgc]}||f}}t ||||||ycc}w)Nz=[{}] '{}' must be an integer or a tuple containing 2 integersrrLr/rMrfris rrCz_Pool2d.__init__$Z(( M$ CJJz=A   #FAszz*h/OPF F !SZZ I-NO#*+7aAq67+ );W,rkrlrmrbs@rrorosx 9=9: X3c3h/0 X sE#s(O345 X %U38_ 456 XXrroc eZdZ ddeeeeeeffdeeeeeeeffdeeeeeeeffffd ZxZS)_Pool3drLr/rMc>t|j}d}t|d|j|d}|t|d|j|d}n|}t|d|j|d}|Dcgc]}||f}}t ||||||ycc}w)Nz=[{}] '{}' must be an integer or a tuple containing 3 integersr'rLr/rMrfris rrCz_Pool3d.__init__rqrkrlrmrbs@rrsrss >B>? X3c3m 445 X sE#sC-$889: X %U3S=%9 9:; XXrrsc leZdZdZ 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) rLr/rMc\t|tjt d |||yNinfrBrCr6maxfloatrJrLr/rMrOs rrCzMaxPool1d.__init__$ %, VWMrrl r^r_r`__doc__rrrrrCrarbs@rrvrvsg048*+ N3c ?+NsE#J/0NsE#J' NNrrvc leZdZdZ 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) rLr/rMcHt|tjd|||yrlrBrCr6meanr}s rrCzAvgPool1d.__init__ ![&'Brrlrrbs@rrrsg048*+ C3c ?+CsE#J/0CsE#J' CCrrc ~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) rLr/rMc\t|tjt d |||yrxrzr}s rrCzMaxPool2d.__init__r~rrlrrbs@rrrs{>9=9: N3c3h/0NsE#s(O345N%U38_ 456 NNrrc ~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) rLr/rMcHt|tjd|||yrlrr}s rrCzAvgPool2d.__init__:rrrlrrbs@rrrs{>9=9: C3c3h/0CsE#s(O345C%U38_ 456 CCrrc 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) rLr/rMc\t|tjt d |||yrxrzr}s rrCzMaxPool3d.__init__ar~rrlrrbs@rrrCs@>B>? N3c3m 445NsE#sC-$889:N%U3S=%9 9:; NNrrc 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) rLr/rMcHt|tjd|||yrlrr}s rrCzAvgPool3d.__init__rrrlrrbs@rrrjs@>B>? C3c3m 445CsE#sC-$889:C%U3S=%9 9:; CCrr)r4 itertoolsrtypingrrrmlx.corecorer6mlx.nn.layers.baserrr%r>r@rdrorsrvrrrrrr+rrrs ))%   *8Z5F5:XeX0XeX0XeX0NN>CC>#N#NL#C#CL$N$NN$C$Cr