Xc@`sddlmZmZmZddlZddlmZddlZddlmZm Z ddl m Z ddl Z ddl m Z ddlmZddlmZdd lmZmZmZdd l mZdd lmZdd lmZdd lmZddlmZddlm Z!ddl"m#Z#e j$Z$gej%j&dd D]Z'e(e'^qRZ)dZ*dZ+dZ,dZ-defdYZ.dfdYZ/ej0e.e/defdYZ1defdYZ2de2fd YZ3d!e2fd"YZ4d#e2fd$YZ5d%e5fd&YZ6d'e5fd(YZ7d)ej8fd*YZ9e9ej:d+d,Z;d-e5fd.YZ<dS(/i(tabsolute_importtprint_functiontdivisionN(tcopy(t iteritemst integer_types(txrange(tgof(tizip(t change_flags(tApplytOptOpenMPOp(tscalar(tget_scalar_type(tpprint(tDisconnectedType(tNullType(t elemwise_cgen(t frozendictt.icC`stddS(NsKCircular dependencies prevent using thishere. import tensor before elemwise(t Exception(tdata((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytas_tensor_variablescO`stddS(NsLCircular dependencies prevent using this here. import tensor before elemwise(R(tinputstkwargs((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt TensorType#scO`stddS(NsLCircular dependencies prevent using this here. import tensor before elemwise(R(RR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytTensorVariable(scO`stddS(NsLCircular dependencies prevent using this here. import tensor before elemwise(R(RR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytTensorConstant-st DimShufflecB`steZdZeZeZd ZedZdZ dZ dZ dZ d Z d Zd Zd ZRS(sR Allows to reorder the dimensions of a tensor or insert or remove broadcastable dimensions. In the following examples, 'x' means that we insert a broadcastable dimension and a numerical index represents the dimension of the same rank in the tensor passed to perform. Parameters ---------- input_broadcastable The expected broadcastable pattern of the input new_order A list representing the relationship between the input's dimensions and the output's dimensions. Each element of the list can either be an index or 'x'. Indices must be encoded as python integers, not theano symbolic integers. inplace : bool, optional If True (default), the output will be a view of the input. Note ---- If `j = new_order[i]` is an index, the output's ith dimension will be the input's jth dimension. If `new_order[i]` is `x`, the output's ith dimension will be 1 and Broadcast operations will be allowed to do broadcasting over that dimension. If `input.broadcastable[i] == False` then `i` must be found in new_order. Broadcastable dimensions, on the other hand, can be discarded. Note ---- .. code-block:: python DimShuffle((False, False, False), ['x', 2, 'x', 0, 1]) This op will only work on 3d tensors with no broadcastable dimensions. The first dimension will be broadcastable, then we will have the third dimension of the input tensor as the second of the resulting tensor, etc. If the tensor has shape (20, 30, 40), the resulting tensor will have dimensions (1, 40, 1, 20, 30). (AxBxC tensor is mapped to 1xCx1xAxB tensor) .. code-block:: python DimShuffle((True, False), [1]) This op will only work on 2d tensors with the first dimension broadcastable. The second dimension of the input tensor will be the first dimension of the resulting tensor. If the tensor has shape (1, 20), the resulting tensor will have shape (20, ). Example ------- .. code-block:: python DimShuffle((), ['x']) # make a 0d (scalar) into a 1d vector DimShuffle((False, False), [0, 1]) # identity DimShuffle((False, False), [1, 0]) # inverts the 1st and 2nd dimensions DimShuffle((False,), ['x', 0]) # make a row out of a 1d vector # (N to 1xN) DimShuffle((False,), [0, 'x']) # make a column out of a 1d vector # (N to Nx1) DimShuffle((False, False, False), [2, 0, 1]) # AxBxC to CxAxB DimShuffle((False, False), [0, 'x', 1]) # AxB to Ax1xB DimShuffle((False, False), [1, 'x', 0]) # AxB to Bx1xA The reordering of the dimensions can be done with the numpy.transpose function. Adding, subtracting dimensions can be done with reshape. tinput_broadcastablet new_ordertinplacecC`st|}||_t|}||_|tkrB||_n tdxt|D]\}}|dkr[t|tt j fst dt |t t |n|t|krtd||t|fn|||dkrtd|qq[q[Wg|_x]t|D]O\}}||kr)|dkr`|jj|qxtd||fq)q)Wg|D]}|dkr|^q|_gt|D]\}}|dkr|^q|_|jridgd6|_ndS( NsRDimShuffle is inplace by default and hence the inplace for DimShuffle must be truetxs?DimShuffle indices must be python ints. Got: '%s' of type '%s'.s4new_order[%d] is %d, but the input only has %d axes.isNThe same input dimension may not appear twice in the list of output dimensionss.You cannot drop a non-broadcastable dimension.i(ttupleRRtTrueR t ValueErrort enumeratet isinstanceRtnumpytintegert TypeErrortstrttypetlentdroptappendtshuffletaugmenttview_map(tselfRRR titjtbR!((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt__init__s>        !   (4 c C`s9t|}t|jj}||jkst|t|jkrdtd|j|fnxWt|j|D]@\}}|tkrw|t krwtd|j|fqwqwWng}x>|j D]3}|dkr|j tq|j ||qWt d|jj d|}t||g|gS(NsTThe number of dimensions of the input is incorrect for this op. Expected %s, got %s.sUThe broadcastable pattern of the input is incorrect for this op. Expected %s, got %s.R!tdtypet broadcastable(RR"R+R8RR,R)tzipR#tFalseRR.RR7R ( R2t_inputtinputtibtexpectedR5tobtvaluetoutput((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt make_nodes(   cC`sI|jr'ddjd|jDSddjd|jDSdS(NsInplaceDimShuffle{%s}t,cs`s|]}t|VqdS(N(R*(t.0R!((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys ssDimShuffle{%s}cs`s|]}t|VqdS(N(R*(RDR!((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys s(R tjoinR(R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt__str__s c C`s|\}|\}|}t|tjkrQt|tjkrQt|n|j|j|j}t|j t |j }x!|j D]}|j |dqW|j |}|jstj|}ntj||dt| dddD]&}|jdtdt|qWdt| ddddg}| | | ||||}|tt |S( Nt__view_or_copycS`sdj|dS(Ns; t;(RE(tlst((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt statements ssif (PyArray_NDIM(%(input)s) != sD){PyErr_SetString(PyExc_NotImplementedError, "input nd"); %(fail)s;}s#if (%(res)s) {Py_XDECREF(%(res)s);}s*{ PyArrayObject * %(basename)s = %(input)ss"Py_INCREF((PyObject*)%(basename)s)s{ PyArrayObject * %(basename)s = (PyArrayObject*)PyArray_FromAny((PyObject*)%(input)s, NULL, 0, 0, NPY_ARRAY_ALIGNED|NPY_ARRAY_ENSURECOPY, NULL)snpy_intp dimensions[%i]R!s dimensions[s] = PyArray_DIMS(%(basename)s)[t]s] = 1snpy_intp strides[%i]sstrides[s*] == 1? 0 : PyArray_STRIDES(%(basename)s)[s] = 0is if (strides[s-1] == 0) strides[s)-1] = PyArray_DESCR(%(basename)s)->elsizeiisPif (strides[%(i)s] == 0) strides[%(i)s] = strides[%(i)s+1] * dimensions[%(i)s+1]R3s5%(res)s = (PyArrayObject*)PyArray_New(&PyArray_Type, s, dimensions, PyArray_TYPE(%(basename)s), strides, PyArray_DATA(%(basename)s), PyArray_ITEMSIZE(%(basename)s), (NPY_ARRAY_WRITEABLE*PyArray_ISWRITEABLE(%(basename)s)), NULL)sif (%(res)s == NULL) %(fail)s;s2PyArray_UpdateFlags(%(res)s, NPY_ARRAY_UPDATE_ALL)s; PyArray_SetBaseObject(%(res)s, (PyObject*)%(basename)s); }( R,RRR*R R%R.RR\tlocals(R2ROtnameRPRQtsubR<RStbasenameRbtnd_intnd_outtcheck_input_ndt clear_outputtget_basetshape_statementsR3totstrides_statementst close_brackett full_code((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytc_codesP          )  7    cC`sdS(Ni(i((R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytc_code_cache_versionvscC`s|\}|\}t|}dgt|jj}x6t|jD]%\}}|dkrG|||st nfunc_specitopenmp(R[RReRRR\titemst destroy_maptufunctnfunctgetattrRR'tsuperRzR6(R2RRReRR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR6s   "    cC`s=t|j}|jd|jd|jdd|S(NRRt__epydoc_asRoutine(Rt__dict__tpopR[(R2td((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt __getstate__s   cC`stt|j|d|_d|_t|j|_t|ddrhtt |j d|_nOd|j j kodknrt j |j j|j j |j j|_ndS(NRii (RRzt __setstate__R[RRRRRR'RRtnint frompyfunctimpltnout(R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs  " c`sK|jjgD]!}td|jjj^q}tgD]}|jj^qD}g}xsD]k}|jj}||} | s|j|ql|j||jj dg| t t ||qlW|gt gD]}|jj ^qD]} t | ^qg|j} |j} | rxgt| D]V\} }xGt | | |jj D](\}}|ro| rotdqoqoWqEWng|jD]}|jj^qtfd| jDr tdgD]}|jj^q| ffntt| ks>t| fS(s`Return the outputs dtype and broadcastable pattern and the dimshuffled niputs. R7R!sIOperation cannot be done inplace on an input with broadcasted dimensions.c3`s/|]%\}}|jj|kVqdS(N(R+R7(RDRnR3(Rt out_dtypes(s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys 2ss:Cannot do an inplace operation on incompatible data types.(RRBRR+R7t make_variabletmaxRR.R8RJRRtallRRRR$toutputstanyRR)R,tAssertionError(R2t dim_shuffleRR3tshadowR<t target_lengthtargstlengtht differencetbcasttout_broadcastablesRt overwritert overwrittenR?R=Rn((RRs6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytget_output_infosB .%     + ?   "1cG`szttt|}|jt|\}}}gt||D]$\}}td|d|^q@}t|||S(s If the inputs have different number of dimensions, their shape is left-completed to the greatest number of dimensions with 1s using DimShuffle. R7R8(RJRRRRRRR (R2RRRR7R8R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRB:s1cC`sg|jdkr\|jrNt|jj}|jd|jt|fSd|jSn|jSdS(NsElemwise{%s}%ss Elemwise{%s}(ReR[RRJRtsortRR*(R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRFHs  cC`s<||tdt}g|D] }d^q}xt|D]\}}g|D]}|j^qQ}tjj|||<|j||} d} xtt ||D]y\} \} } | | dks&t | | j t rq| dk r| dkr| | | } q&| | | | } qqW| ||W|S(NRZ( R\R#R[R%RwRtRut ones_liket_bgradRR&R+R(R2RR]toutsR!RXtidxRQtogradstbgradstrop_outtjdxRPt eval_point((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR^Ss$   cC`sRt|jdr"|jj|Sg|jD]"}g|jD] }t^q<^q,S(Ntconnection_pattern(thasattrRRRRR#(R2ROtiptRA((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRusc C`s|j||}td|Drg}xt||D]\}}t|jttfrr|j|q>|j}t |jj t j j kr|jt jj}nt |jj t j jkst|j|q>W|Sxt|D]\}}t||jttfr(qngt|jjD]*\} } | r;|dj|  r;| ^q;} | rt j jj||d| dt} | ||sitaxistkeepdims(RRRR&R+RRR.RwR*R7RtRuRtastypeRxRyRvRR%R8tbasictsumR#( R2RRRRXtnew_rvaltelemRR3R4Rtto_sumtsr((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytL_op|s.   $$ c `s]tddyd}tt|tt||jj}x)|D]!}|dk s_t|jq_WWdQXt|ttfst dt |jt t |fnt dj j fdg}xOt|D]>\}}|dkrB|jdqn|j|qW|S(Ntcompute_test_valuetoffcS`s/t|jttfr|St|jjS(N(R&R+RRRR7(tt((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt as_scalarss,%s.grad returned %s instead of list or tupleic`st|jttfr|S|kr9j|S|krVj|S|j}|dkrtjj t j |j d|jj }tddg|St|jig|jD]}|^q}|S(NR7R!((R&R+RRtindexRR[RtRutconstantR'RNRR7RRzRR(RRORSRtnew_r(RtndRt scalar_inputst scalar_ogradst transform(s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs    %(R RJRRRR[RR&R"R)R*R+R,R8RR.( R2RRRt scalar_igradstigradtrett scalar_igradR((RRRRRRs6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs&  %(  c C`st|jdkr|jdks?|jjt|jkr|jdkr|dkrtj|jj t|j|jj }|jjdkr||_q||j _n|j dj }|tjjkr>t|jtjr>|jdj tjjkr>tj|}||jd||j }||j _nt|jg|jD]!} td| jj j^qQg|j D]!} td| jj j^q|j _|jj|j jdd|dS(Ni tpyis->R7(R,RRR[RRRR'RRRttagRR7RtRut float_dtypesR&Rvt sctype2chartsigR RR+Rt fake_nodet prepare_node( R2ROt storage_mapt compute_mapRRt out_dtypetcharRR<RA((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs2    +7cC`st|jdkr4tt|j|||nxtgt||jD]*\}}tt|j|j j ^qMD]9}t d|Ddkr~dt f|kr~g}t|t|jkst xt||jD]\}}t|jt|j j kst g}xOt|j|j j D]5\} } | r`|dg7}q>|t| g7}q>W|jddj|qWddj|} t| q~q~Wg} x{tg|D]}|j^qD]W} td| Dr(t | dkst | jd q| jt | qWt| } |}i}|jrt||jdkr|j}|jd }t|jd r-|jj|d sit*s(%s)s, s!Dimension mismatch; shapes are %scs`s|]}|dkVqdS(iN((RDR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys 1siiRRRR7ttobject.(*R,RRRzRURR9RJRKR+R8RR:RR*R.RER$RR"RRRRRRRR[RRRR'RNR7RR&RGtnumtviewtflagstowndataR(R2RORtoutput_storageR<tsinputtdimstmsgtmsg2RR5t base_exc_strt out_shapetvaluest ufunc_argst ufunc_kwargsRRt variablesR3tvariableRRtodat((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRUs~ G.!'%) "             !   c C`sg}x|jD]}g}xt|jjD]\}}d}|rPd}nlxit||jD]U\} } t| jtj j rqcn| jj|sc| |r| |}PqqcqcW|j |q/W|j t |qW|S(Ni( RR%R+R8R[RRR&RtR tScalarR.R"( R2ROti_shapesRXRntoshptdimR5tb_dimRWR3((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRYs"    c= C`s t|jds+|j|dddn|}|}tjj|}tjj|j}t|t|ks|t t t tjjt t ||j\} } t gt | |D]\} } | | k^qst t gt | |D]\} } | | k^qs&t d} d}t gt|jD])\}}|j||j|gf^qE}g|D]}|jjd^q~}t t gt|j|D]4\}}||kr|||jjdf^q}|r|\}}}nggg}}}t t gt|j|D]$\}}||kr;||f^q;}|r|\}}n gg}}g|D]=}gt|jjD]\}} | rdp|^q^q}t|d}t |}x7tt||D] \}\}}||d|%%(lv%(i)s)s_iter = (%(dtype)s*)(PyArray_DATA(%%(lv%(i)s)s)); t s { %(defines)s %(init_array)s %(task_decl)s %(task_code)s %(undefs)s } t loop_orderstdtypest loop_tasksRfRtinit_loop_orderst olv_indext inner_taskt_scalar_contig_s // All output have the same size npy_intp n = PyArray_SIZE(%(z)s); sg dtype_%(x)s * %(x)s_ptr = (dtype_%(x)s*) PyArray_DATA(%(x)s); sN dtype_%(x)s& %(x)s_i = %(x)s_ptr[i]; si dtype_%(x)s& %(x)s_i = ((dtype_%(x)s*) PyArray_DATA(%(x)s))[0]; s;#pragma omp parallel for if(n>=%d) s for(int i=0; iscs`s|]}|jdkVqdS(RON(R7(RDRn((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys st inner_float16s ( RRRRRR:RRzRrRERN(R2ROR"R#R$RfRC((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRrs %$cC`s ddgS(Nss ((R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt c_headersscC`s |jjS(N(Rtc_support_code(R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRRscC`s|jj||d}|S(NR (Rtc_support_code_apply(R2ROR"t support_code((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRSs cC`sdg}t|jg|jD]!}td|jjj^qg|jD]!}td|jjj^qJ}|j|jj |x:|j|jD](}|jtd|jjj qW|jd|j ft |rt |SdSdS(Ni R7R((R RRRR+R7RRR.tc_code_cache_version_applyRsRRR"(R2ROtversionR<RAt scalar_nodeR3((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRUs +1   cC`s)|jdjdko(t|jdkS(ss Return True if we do not want to compile c code when doing constant folding of this node. ii (RRR,R(R2RO((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytpython_constant_foldings(RRRRR[R6RRRRBRFR^RRRRRURYRNRrRQRRRSRURX(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRzs0/   9  "  3 3 . o !     tCAReducecB`seZdZdZddZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZRS(sQ CAReduce = Commutative Associative Reduce Reduces a scalar operation along the specified axis(es). (The scalar op should be both commutative and assocative) The output will have the same shape as the input minus the reduced dimensions. It will contain the variable of accumulating all values over the reduced dimensions using the specified scalar op. Parameters ---------- scalar_op A binary scalar op with only one output. It must be commutative and associative. axis - The dimension along which we want to reduce - List of dimensions that we want to reduce - If None, all dimensions are reduced Note ---- .. code-block:: python CAReduce(add) # sum (ie, acts like the numpy sum operation) CAReduce(mul) # product CAReduce(maximum) # max CAReduce(minimum) # min CAReduce(or_) # any # not lazy CAReduce(and_) # all # not lazy CAReduce(xor) # a bit at 1 tell that there was an odd number of # bit at that position that where 1. 0 it was an # even number ... In order to (eventually) optimize memory usage patterns, CAReduce makes zero guarantees on the order in which it iterates over the dimensions and the elements of the array(s). Therefore, to ensure consistent variables, the scalar operation represented by the reduction must be both commutative and associative (eg add, multiply, maximum, binary or/and/xor - but not subtract, divide or power). RRcC`s|jdks|jdkr-tdn||_|dkrN||_nt|ttj fru|f|_ntt|tj r|j dkrt |f|_n>t td|D|_|jjt|j|_|j|dS(Niiis=CAReduce only supports binary functions with a single output.ics`s|]}t|VqdS(N(tint(RDta((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys s(ii(RRtNotImplementedErrorRR[RR&RR'R(RGRRZRJtsetRR"t set_ufunc(R2RR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR6s    ! cC`sBt|tjjjr'tj|_nt|tjjjrNtj |_nt|tjjj rutj |_nt|tjjj rtj |_nt|tjjjrtddgkrtj|_nit|tjjjrtj|_nBt|tjjjr#tj|_ntj|jdd|_dS(Nii i(R&RtR RtAddR'taddRtMultmultiplytMaximumtmaximumtMinimumtminimumtANDt _numpy_vert bitwise_andtORt bitwise_ortXORt bitwise_xorRR(R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR^s cC`s|S(N((R2t input_dtype((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt _output_dtype7sc C`st|}|jdk rxc|jD]U}||jjksa|dkr%t||jjkr%td||fq%q%Wnt|}|j}|dkrttt |jj }nt d|Drxg}xD|jD]9}|dkr|j ||jjq|j |qWt |t |ksDt t|}t|}|j|j||_n|}gt|jj D]\}}||kr|^q}td|j|jjd|} t||g| gS(Nis0Not enough dimensions on %s to reduce on axis %scs`s|]}|dkVqdS(iN((RDR[((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys HsR7R8(RRR[R+RtabsR$RJRR,R8RR.RR"RR^RR%RRoR7R ( R2R<Rtaxis2R[RR3R!R8RA((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRB:s: $   !     cC`s#t|j}|jdd|S(NR(RRRR[(R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR^scC`s$|jj||j|jdS(N(RtupdateR^R(R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRcscC`sE|jdk r6d|jdjd|jDfSd|jSdS(NsReduce{%s}{%s}s, cs`s|]}t|VqdS(N(R*(RDR!((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys jss Reduce{%s}(RR[RRE(R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRFgs$c C`s|\}|\}|j}|dkr?tt|j}n|}tt|}t|dr|jdk r|j} n|j dj j } |rx|D]} |j | dkr2t|j drt|j } | | =tjt| d| }|j|j jqMtd|| |j fq|jj|| d| }qWtj|}tj||r|j}ntj|d|j dj j |d         cC`se|\}|j}|dkr"dSgt|jdjjD]"\}}||kr<||^q<fS(Ni((((RR[R%RR+R8(R2RORVtishapeRR3R5((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRYs   #c& C`s)|jd}|jd}|d}|d} |jjd} |jjd} t|dr|jdk r|jdkrtjj j dnt d|jdj d|j} | jd} n| } |j }|dkr ttt|jj }nt|dkrtjj||jdj}||kr_ttj|}n|j|jdjks~t|jjj|j||||Sgt|jjD]}||kr|^q}|t|}t|}t|}x:tt|j|D] \}\}}||d|s ((R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRQUscC`sdg}t|jg|jD]!}td|jjj^qg|jD]!}td|jjj^qJ}|j|jj |x:|j|jD](}|jtd|jjj qWt |rt |SdSdS(NiR7(( R RRRR+R7RRR.RURsRR"(R2RORVR<RARWR3((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRUYs +1   (s scalar_opsaxisN(RRRRR[R6R^RoRBRRRFRURYRNRrRQRU(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRYs*    $    /  tAllcB`sDeZdZdZddZdZdZdZdZ RS( s\ Applies `logical and` to all the values of a tensor along the specified axis(es). RcC`stj|tj|dS(N(RYR6R tand_(R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR6uscC`sdS(Ntbool((R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRoxscC`s4|jdkrdSddjtt|jSdS(NRsAll{%s}s, (RR[RERR*(R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRF{scC`sOt|}|jdkr3tjj|d}ntt|j|}|S(NRi(RR7RtRutneqRRRB(R2R<R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRBs  cC`s|\}|jtjjgS(N(RwRtRxRy(R2RPR|R!((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs (saxisN( RRRRR[R6RoRFRBR(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRns    tAnycB`sDeZdZdZddZdZdZdZdZ RS( s[ Applies `bitwise or` to all the values of a tensor along the specified axis(es). RcC`stj|tj|dS(N(RYR6R tor_(R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR6scC`sdS(NR((R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRoscC`s4|jdkrdSddjtt|jSdS(NRsAny{%s}s, (RR[RERR*(R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRFscC`sOt|}|jdkr3tjj|d}ntt|j|}|S(NRi(RR7RtRuRRRRB(R2R<R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRBs  cC`s|\}|jtjjgS(N(RwRtRxRy(R2RPR|R!((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs (saxisN( RRRRR[R6RoRFRBR(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs    t CAReduceDtypecB`sSeZdZd Zd d d dZdZdZdZd Z d Z RS( sQ Reduces a scalar operation along the specified axis(es). This subclass of CAReduce accepts an additional "dtype" parameter, that specifies which dtype the output should be. It also accepts an optional "acc_dtype", which specify the dtype that will be used for the accumulation. So, the accumulation will be done into a tensor of dtype "acc_dtype", then it will be casted into "dtype" and returned. If no dtype is provided, one will be inferred so as not to lose too much precision. Parameters ---------- scalar_op A binary scalar op with only one output. It must be commutative and associative. axis * the dimension along which we want to reduce * list of dimensions that we want to reduce * if None, all dimensions are reduced dtype The dtype of the returned tensor. If None, then we use the default dtype which is the same as the input tensor's dtype except when: * the input dtype is a signed integer of precision < 64 bit, in which case we use int64 * the input dtype is an unsigned integer of precision < 64 bit, in which case we use uint64 This default dtype does _not_ depend on the value of "acc_dtype". This behavior is similar in spirit to that of numpy (except numpy uses the default machine integer while we always use 64 bit integers to avoid platform-dependent behavior). acc_dtype The dtype of the internal accumulator. If None (default), we use the dtype in the list below, or the input dtype if its precision is higher: * for int dtypes, we use at least int64; * for uint dtypes, we use at least uint64; * for float dtypes, we use at least float64; * for complex dtypes, we use at least complex128. RRR7RscC`s,tj||d|||_||_dS(NR(RYR6R7Rs(R2RRR7Rs((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR6s cC`sPtt|j|t|ds1d|_nt|dsLd|_ndS(NR7tOLDRs(RRRRR7R[Rs(R2R((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs  cC`s|j}|dkrLtdddddddddddd j||S|dkrtd ddddddddd dd dd j||S|SdS( NRtint8tint32tint16tint64tuint8tuint32tuint16tuint64R(R7R\RR[(R2RR7((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRos&   cC`s|j}|dkrdtddddddddddddd dd d d d d d j||S|tjjkr|tjjkr|Stj ||}||krt d|||||fn|SdS(NRRRRRRRRRRORRt complex64t complex128sCannot build %s node with input dtype %s and acc_dtype %s, as precision would be lost. To correct this error, you can: - not specify acc_dtype, or - use an acc_dtype at least as precise as %s. - specify "dtype" instead of "acc_dtype", so the reduction will be precise, but the result will be casted into "dtype" at the end. If you are expecting the precision loss, you can use tensor.cast(..., dtype="%s"), on your input.( RsR[R\RRtRuRRvR tupcastR)(R2RRstupcasted_dtype((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyt _acc_dtype s,    cC`st|}|j|j}|j|j}|dk sBt|dk sTt||jkr{||jkr{|}n.t|}|j|j ||_||_|jdk stt j ||S(N( RRoR7RR[RRsRR^RRYRB(R2R<R7RsR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRB1s     cC`s|jj}|jjdkr1d|jf}nd}|jdk rodjd|jD}d|}nd||t|jfS(NRsReduceDtype{%s}Rs, cs`s|]}t|VqdS(N(R*(RDR!((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys Lss axis=[%s], s%s{%sacc_dtype=%s}(t __class__RRRR[RER*Rs(R2ReR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRFFs  (s scalar_opsaxissdtypes acc_dtypeN( RRRRR[R6RRoRRBRF(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs3  $ tSumcB`sAeZdZdZd d d dZdZdZdZRS( s  Sums all the values of a tensor along the specified axis(es). Equivalent to `CAReduceDtype(scalar.add, axis=axis, dtype=dtype)`, with the difference that this defines the gradient of sum wrt its tensor input. Parameters ---------- axis Axis(es) along which the tensor should be summed (use None to sum over all axes, and a list or tuple to sum along more than one axis). dtype The dtype of the internal accumulator and returned tensor. If None, then we use the default dtype which is the same as the input tensor's dtype except when: - the input dtype is a signed integer of precision < 64 bit, in which case we use int64 - the input dtype is an unsigned integer of precision < 64 bit, in which case we use uint64 This value does not depend on the value of "acc_dtype". acc_dtype The dtype of the internal accumulator. If None (default), we use the dtype in the list below, or the input dtype if its precision is higher: - for int dtypes, we use at least int64; - for uint dtypes, we use at least uint64; - for float dtypes, we use at least float64; - for complex dtypes, we use at least complex128. RR7Rsc C`s)tj|tjd|d|d|dS(NRR7Rs(RR6R R`(R2RR7Rs((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR6{scC`sd|jj}d}|jdk rJdjd|jD}d|}nd||t|jfS(NRs, cs`s|]}t|VqdS(N(R*(RDR!((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pys ss axis=[%s], s%s{%sacc_dtype=%s}(RRRR[RER*Rs(R2ReR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRFs  c C`s/|\}|djtjjkr;|jdtjjgS|\}t|}|j}|dkrt t |j j }n|dkr|fSg}d}xSt|j jD]?\} } | |kr|jdq|j||d7}qWt|j j|} ttj|| |} | gS(NiR7R!i((R7RtRuRRwRxRyRRR[RJRR+RR%R8R.RRzR tsecond( R2RPRQR|R!R}Rtnew_dimsR3R4t_tds_optgx((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs(        cC`s)d|krdgS||tdtS(NRZ(R[R\R#(R2RR]((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR^s (saxissdtypes acc_dtypeN( RRRRR[R6RFRR^(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRUs " tProdcB`sDeZdZdZd d d edZdZdZdZ RS( s Multiplies all the values of a tensor along the specified axis(es). Equivalent to `CAReduce(scalar.prod, axis = axis)`, with the difference that this defines the gradient of prod wrt its tensor input. RR7Rsc C`s2tj|tjd|d|d|||_dS(NRR7Rs(RR6R tmultno_zeros_in_input(R2RR7RsR((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR6s cC`s2tt|j|d|kr.t|_ndS(NR(RRRR:R(R2tdct((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs cC`s?|\}|\}|djtjjks@|jtjjkrY|jdtjjgSt|}|j }|dkrt t |j j}n|dkr|fSg}d}xSt|j jD]?\} } | |kr|jdq|j||d7}qW||j|} |j|}|| |} |jrL| gStj} | j|d}| j|d|j }| j|dj|}||}| j|d}||}||}td|j |}|j|}| j|dj|}| j|| | j||d|}|gSdS( sy The grad of this Op could be very easy, if it is was not for the case where zeros are present in a given "group" (ie. elements reduced together to form the product). If no zeros are found in the elements of the product, then the partial derivative of the product relative to one of the elements (one of the inputs) is simply the product of the other elements. That's easy to see from the chain rule. Now the trick (with no zeros) is to take the overall product, then for every original element, the partial derivative is given by this product divided by the element itself (which equals the product of the other terms). This is easy to do by broadcasting the original product. (Note that we also need to broadcast-multiply by the "incoming gradient", ie. the gradient of the cost relative to the output/product). With zeros, things get more complicated. For a given group, we have 3 cases: * No zeros in the group. Use previous trick. * If only one zero is present, then the gradient for that element is non-zero, but is zero for all others. * If more than one zero is present, then all the derivatives are zero. For the last two cases (with 1 or more zeros), we can't use the division trick, as this gives divisions by 0. Implementing that case-by-case logic is not as trivial, so a bunch of hacks are piled down here to do it. Notably, for the "only one zero" case, there's a special Op that computes the product of the elements in the group, minus the zero (see ProdWithoutZero). The trick is then to use the division trick for groups with no zero, to use the ProdWithoutZeros op where there's only one zero, and to output a derivative of zero for any element part of a group with more than one zero. I do this by first counting the number of zeros in each group (see the "T.eq()" bits), then taking this or that behavior (see T.switch) based on the result of this count. iR7R!igRN((R7RtRuRvRsRwRxRyRRR[RJRR+RR%R8R.t dimshuffleRteqRRtProdWithoutZerostswitch(R2RPRQR|tprod_inR}RRR3R4Rtprod_outtgrad_case_without_zerostTt where_zerostsum_where_zerostgroups_with_single_zerotwhere_single_zerotwhere_gz_not_zerot where_to_take_prod_without_zerostprod_without_zeros_intprod_without_zerostgroups_without_zerost final_grad((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRsT.                cC`sdS(Ni(i((R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs=s(saxissdtypes acc_dtypeN( RRRRR[R:R6RRRs(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRs    ztMulWithoutZeroscB`s5eZdZeZeZdZdZdZRS(gcC`s(|dkr|S|dkr |S||S(Ni((R2R!R)((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRLs   c C`s$|\}}|\}ddtS(Ns"%(z)s = ((%(x)s == 0) ? (%(y)s) : s/((%(y)s == 0) ? (%(x)s) : ((%(y)s)*(%(x)s))) );(Rd( R2ROReRPRQRfR!R)R;((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRrSs   cC`sdS(Ni(i((R2((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRsZs( RRR{R#t commutativet associativeRRrRs(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRAs   Retmul_without_zerosRcB`s)eZdZddddZdZRS(RR7Rsc C`s&tj|td|d|d|dS(NRR7Rs(RR6R(R2RR7Rs((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyR6escC`s+|\}tjj|d|d}|gS(Nis2nd derivatives of `product(a)` is not currently supported.If `a` is guarenteed to contains no zeros, use `product(a, no_zeros_in_input=True)`.(Rttgradienttgrad_not_implemented(R2RPR|R[ta_grad((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRis     (saxissdtypes acc_dtypeN(RRRR[R6R(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pyRas(=t __future__RRRtsysRR'tsixRRt six.movesRRtRt theano.compatRttheano.configparserR t theano.gofR R R R t theano.scalarRttheano.printingRttheano.gradientRttheano.gof.null_typeRt theano.tensorRRttheano.misc.frozendictRRxt __version__tsplittnRZRhRRRRRRtassignRzRYRRRRRtBinaryScalarOpRt upcast_outRR(((s6/tmp/pip-build-X4mzal/theano/theano/tensor/elemwise.pytsT    /    V5W