
    ;5i"                        d dl Z d dlmZ d dlmc mZ d dlmZ d dlm	Z	 d dl
mZmZ d dlZdZd$dZd$dZd%dZd%d	Zd%d
Zd&dZddej,                  z  fdZd$dZd$dZd'dZdefdefdefdefdefdefdefdefdefdd$dff
Z G d dej8                        Z G d dej8                        Zd  Zd! Z d" Z!e"d#k(  r e!        yy)(    N)
DataLoader)datasets
transforms:0yE>   c                 ,    | j                  |      d   S )z,Max across input signals (subdifferentiable)dimr   )maxsignalsr
   s     "deepseek_python_20260413_975927.pyop_maxr          ;;3;""    c                 ,    | j                  |      d   S )zMin across input signalsr	   r   )minr   s     r   op_minr      r   r   c                     t        j                  t        j                  |       |z         }t        j                  |       j	                  |      }|t        j
                  |j                  |            z  S )u>   Product across signals – numerically stable via log-sum-exp.r	   )torchlogabssignprodexpsum)r   r
   epslog_signalsr   s        r   
op_productr      sY    ))EIIg.45K::g###,D%))KOOO4555r   c                    | j                  |      }t        j                  t        j                  |       |z         j	                  |      }t        j
                  |       j                  |      }|t        j                  ||z        z  S )u    Geometric mean = (∏ x_i)^(1/N)r	   )sizer   r   r   r   r   r   r   )r   r
   r   nlog_sumr   s         r   op_geometric_meanr$      sn    SAii		'*S0155#5>G::g###,D%))GaK(((r   c                 d    | j                  |      }d| |z   z  j                  |      }|||z   z  S )u   Harmonic mean = N / (∑ 1/x_i)      ?r	   )r!   r   )r   r
   r   r"   inv_sums        r   op_harmonic_meanr(   $   s;    SAgm$))c)2G#r   c                 `    t        j                  | |z  |      }|| z  j                  |      S )z3Weighted sum with softmax attention across signals.r	   )r   softmaxr   )r   r
   temperatureweightss       r   op_softmax_fusionr-   *   s0    mmGk1s;Gg""s"++r      c                 0    | j                  |      }||z  S )u/   (∑ x_i) mod period – phase wrapping effect.r	   )r   )r   r
   periodtotals       r   op_modular_additionr2   /   s    KKCK E6>r   c                     t        | |      S )z+Plain multiplication (alias for op_product)r	   )r   r   s     r   op_multiplicationr4   4   s    g3''r   c                 |    | j                  |d      }| |z
  }t        j                  |      j                  |      S )u5   Simplified phase coupling: sum of sin(θ_i - mean_θ)Tr
   keepdimr	   )meanr   sinr   )r   r
   r8   diffs       r   op_synchronizationr;   8   s;     <<C<.DT>D99T?3''r   c                 r    | |kD  j                  |      }| j                  |      j                  | d      S )zAOnly keep features where all signals > threshold (sparse masking)r	           )allr8   masked_fill)r   r
   	thresholdmasks       r   op_hadamard_mixrB   ?   s:    i$$$-D<<C< ,,dUC88r   r   r   productgeometric_meanharmonic_meansoftmax_fusionmodular_addsynchronizationhadamard_mixr8   c                 &    | j                  |      S )Nr	   )r8   )sr
   s     r   <lambda>rL   O   s    afffo r   c                   0     e Zd ZdZd fd	Zd Zd Z xZS )OperatorGatedLinearzz
    Fully connected layer where the summation over input features
    is replaced by a learned mixture of operators.
    c           
         t         |           || _        || _        || _        t        j                  t        j                  ||            | _	        |r.t        j                  t        j                  |            | _
        n| j                  dd        t        j                  t        j                  dd      t        j                         t        j                  dt        t                           | _        | j%                          y )Nbiasr      )super__init__in_featuresout_featurestempnn	Parameterr   TensorweightrP   register_parameter
SequentialLinearReLUlen	OPERATORS
controllerreset_parameters)selfrT   rU   rP   rV   	__class__s        r   rS   zOperatorGatedLinear.__init__Z   s    &(	 ll5<<k#JKU\\,%?@DI##FD1 --IIaOGGIIIaY(
 	r   c                    t         j                  j                  | j                  t	        j
                  d             | j                  xt         j                  j                  | j                        \  }}|dkD  rdt	        j
                  |      z  nd}t         j                  j                  | j                  | |       y y )N   )ar   r   )	rW   initkaiming_uniform_rZ   npsqrtrP   _calculate_fan_in_and_fan_outuniform_)rc   fan_in_bounds       r   rb   z$OperatorGatedLinear.reset_parametersp   s    
  
 ;99 ==dkkJIFA+1A:A'1EGGTYY6 !r   c           
      z   |j                  d      }|j                         }||j                  dd      t        z   z  }|t	        j
                  |t        z         z  j                  dd       }| j                  |      }t        j                  || j                  z  d      }d}|j                  || j                        }	t        d| j                  |      D ]  }
t        |
|z   | j                        }| j                  |
| }|j                  d      |j                  d      z  }| j                   #|| j                   |
| j#                  ddd      z   }|j%                  |||
z
        }t'        t(              D ]0  \  }\  }}|j+                   ||d      |d d ||dz   f   z         2 ||	d d |
|f<    |	S )	Nr   r   Tr6   r	       r.   )r!   r   r   EPSr   r   ra   Fr*   rV   	new_emptyrU   ranger   rZ   	unsqueezerP   view	new_zeros	enumerater`   add_)rc   x
batch_sizeabs_xpentropygate_logits
op_weights
chunk_sizeoutputiendchunk_wr   	chunk_outjro   op_funcs                     r   forwardzOperatorGatedLinear.forwardw   s   VVAY
 UYY1dY3c9:		!c'**//At/DDoog.YY{TYY6A>

Z):):;q$++Z8 
	)Aa*nd&7&78Ckk!C(Gkk!nw'8'8';;Gyy$!DIIa$4$9$9!R$CC))*cAg>I#,Y#7 Q<AwwwA6AqQwJ9OOPQ(F1ae8
	) r   )Tg      ?)__name__
__module____qualname____doc__rS   rb   r   __classcell__rd   s   @r   rN   rN   U   s     ,7r   rN   c                   4     e Zd ZdZdg ddf fd	Zd Z xZS )OperatorCollapseNetzk
    Simple MLP with OperatorGatedLinear layers.
    Flatten 3x32x32 -> 3072 -> 256 -> 128 -> 64 -> 10
    i   )      @   
   c                 d   t         |           g }|}|D ]f  }|j                  t        ||             |j                  t	        j
                  |             |j                  t	        j                                |}h |j                  t        ||             t	        j                  | | _        y )N)	rR   rS   appendrN   rW   BatchNorm1dr^   r\   net)rc   	input_dimhidden_dimsnum_classeslayersprev_dimhdimrd   s          r   rS   zOperatorCollapseNet.__init__   s     	DMM-h=>MM".../MM"'')$H		
 	)(K@A==&)r   c                 f    |j                  |j                  d      d      }| j                  |      S )Nr   rs   )ry   r!   r   )rc   r}   s     r   r   zOperatorCollapseNet.forward   s(    FF166!9b!xx{r   )r   r   r   r   rS   r   r   r   s   @r   r   r      s     "&>r 
*r   r   c                    | j                          t        |      D ]  \  }\  }}|j                  |      |j                  |      }}|j                           | |      }t	        j
                  ||      }	|	j                          |j                          |dz  dk(  st        d| d|t        |      z   dt        |j                         dd|z  t        |      z  dd	|	j                         d

        y )Nd   r   zTrain Epoch: z [/ (      Y@.0fz
%)]	Loss: z.6f)trainr{   to	zero_gradru   cross_entropybackwardstepprintr_   datasetitem)
modeldevicetrain_loader	optimizerepoch	batch_idxdatatargetr   losss
             r   r   r      s    	KKM%.|%< 	^!	>D&wwv		&(9ftvv.s?aM%9s4y+@*A3|G[G[C\B] ^Y&\)::3?{499;WZJ[] ^	^r   c                    | j                          d}d}t        j                         5  |D ]  \  }}|j                  |      |j                  |      }} | |      }|t	        j
                  ||d      j                         z  }|j                  dd      }||j                  |j                  |            j                         j                         z  } 	 d d d        |t        |j                        z  }t        d|dd	| d
t        |j                         dd|z  t        |j                        z  dd	       y # 1 sw Y   hxY w)Nr   r   )	reductionr   Tr6   z
Test set: Average loss: z.4fz, Accuracy: r   r   r   r   z%)
)evalr   no_gradr   ru   r   r   argmaxeqview_asr   r_   r   r   )	r   r   test_loader	test_losscorrectr   r   r   preds	            r   testr      s<   	JJLIG	 B' 	BLD&776?FIIf,=&D4[F5INNPPI==Q=5Dtwwv~~d3488:??AAG	BB [(())I	&yo 6iq[%8%8!9 :"TG^cR]ReReNf=fgj<kkoq rB Bs   B0EE
c                  ~   t         j                  j                         } t        j                  | rdnd      }t	        d|        t        j                  t        j                         t        j                  dd      g      }t        j                  ddd|      }t        j                  dd	d|      }t        |d
dd      }t        |d
d	d      }t               j                  |      }t        j                  |j!                         d      }t#        dd      D ]  }	t%        |||||	       t'        |||         y )NcudacpuzUsing device: )gHPs?gec]?g~jt?)gۊe?ggDio?g|?5^?z../dataT)rootr   download	transformFrr   r   )r~   shufflenum_workersgMbP?)lrr      )r   r   is_availabler   r   r   ComposeToTensor	Normalizer   CIFAR10r   r   r   optimAdam
parametersrw   r   r   )
use_cudar   r   train_datasettest_datasetr   r   r   r   r   s
             r   mainr      s   zz&&(H\\H&%8F	N6(
#$ ""57OP$ I $$)4$ZcdM##%$ZcdLmDVWXL\b%UVWK!$$V,E

5++-%8Iq" )eV\9e<UFK()r   __main__)r   )r   r   )r   r&   )r   r=   )#r   torch.nnrW   torch.nn.functional
functionalru   torch.optimr   torch.utils.datar   torchvisionr   r   numpyrj   rt   r   r   r   r$   r(   r-   pir2   r4   r;   rB   r`   ModulerN   r   r   r   r   r    r   r   <module>r      s        ' , 
##6),
 &'qw 
((9 FO
FO
()&'()'(*+_%-.	 <")) <B")) 0^r$). zF r   