Xc@`sdZddlmZmZmZddlmZddlZddlZddl Z ddl m Z ddlm Z ddl Z ddlZddlmZddlmZdd lmZdd lmZmZmZmZdd lmZdd lmZdd lmZmZm Z m!Z!ddl"m#Z#m$Z$ddl%m&Z&ddlm'Z(ddl)m*Z*ddlm+Z+m,Z,ddl-m.Z.m/Z/ddl0m1Z1m2Z2m3Z3ddl4Zddl5m6Z6ddl5m7Z7ddl5m8Z8ddl9m:Z:m;Z;m<Z<m=Z=ddl>Z>e>j?dZ@dZAeBZCeDZEeFZGeHeIeJe(jKZLeHeIeJe(jMZNeHeIeJe(jOZPeHeIeJe(j ZQeHeIeJe(jRZSeHeIeJe(jTZUeHeIeJe(jVZWeHeIeJe(jXZYdeZfdYZ[dZ\e+j]e\gZ^dZ_dZ`eaead ZbebZcebZdeaeaead!Zeeaeaead"Zfegef_hiZid#Zjekejljmd$krd%Znd&Zod'Zpd(Zqd)Zrd(Zsn]ekejljmrd*Znd%Zod)Zpd(Zqd)Zrd(Zsn$d(Znd(Zod+Zpd+Zqd+Zrd,Zsd-Zteaead.Zud/eZfd0YZvd1evfd2YZwd3Zxe(jye(jze(j{e(j|e(j}e(j~e(je(je(je(je(je(je(je(je(je(jfZeged4d5Zd6Zld7Ze#d8fZe#d9fZe#d:fZe#d;fZe#d<fZe#d=fZe#d>fZe#d?fZeaead@Z'ee'eeee\ZZZZZeeeefZVeefZOeefZKeVZeOZeKZe#d8efZe#d9efZe#d:efZe#d;efZe#d<efZe#d=efZe#d>efZe#d?efZeaeadAZeeeeee\ZZZZZeeeefZeefZeefZe#d8eefZe#d9eefZe#d:eefZe#d;eefZe#d<eefZe#d=eefZe#d>eefZe#d?eefZeaeadBZeeeeee\ZZZZZeeeefZeefZeefZe#d8egefZe#d9egefZe#d:egefZe#d;egefZe#d<egefZe#d=egefZe#d>egefZe#d?egefZeaeadCZeeeeee\ZZZZZe#d8eegfZe#d9eegfZe#d:eegfZe#d;eegfZe#d<eegfZe#d=eegfZe#d>eegfZe#d?eegfZeaeadDZeeeeee\ZZZZZe#d8efdEZe#d9efdEZe#d:efdEZe#d;efdEZe#d<efdEZe#d=efdEZe#d>efdEZe#d?efdEZeaeadFZeeeeee\ZZZZZe#d8efdGZe#d9efdGZe#d:efdGZe#d;efdGZe#d<efdGZe#d=efdGZe#d>efdGZe#d?efdGZeaeadHZeeeeee\ZZZZZe#d8efdIZe#d9efdIZe#d:efdIZe#d;efdIZe#d<efdIZe#d=efdIZe#d>efdIZe#d?efdIZeaeadJZeeeeee\ZZZZZe#Zebe_be#e_#ee_e e_ dKZeeaeaeaZdLZdMefdNYZ e Z dOefdPYZ e Z dQZ e ej:e(jdRZe ej:e(jd<Ze ej:e(jd=Ze ej:e(jd>Ze ej:e(jd?Ze ej:e(jdSZe ej:e(jdTZe ej:e(jdUZe ej:e(jdVZe ej:e(j dWZ!e ej:e(j"d:Z#e ej:e(j$d;Z%e ej:e(j&d8Z'e ej:e(j(d9Z)iedR6ed<6ed=6ed>6ed?6edS6edT6edU6edV6e!dW6e#d:6e%d;6e'd86e)d96Z*e_dXZ+dYefdZYZ,d[efd\YZ-e-Z.d]Z/e_eaed^Z0e_eaed_Z1e_eaed`Z2e_eaedaZ3e_eaedbZ4e_dcZ5e_ddZ6edeZ7edfZ8edgZ9edhZ:ediZ;edjZ<edkZ=e=Z>dlZ=edmZ?e?Z@dnZ?d+d,edoZAd+d,edpZBedqZCeCZDedrZEeEZFedsZGeGZHedtZIeIZJeduZKeKZLedvZMe.jNeMe,jOdwdxfedyZPedzZQed{ZRed|ZSed}ZTed~ZUedZVedZWedZXedZYedZZedZ[edZ\e_eadZ]e_eadZ^edZ_edZ`edZaeaZbedZcedZdedZeedZfedZgedZhedZiedZjedZkedZledZmedZnedZoedZpedZqedZredZsedZtedZuedZvedZwedZxedZyedZzedZ{edZ|edZ}edZ~ee~e!_~edZeee!_edZedZBedZedZedZeZe.jNee,jde_eaedZe_eaedZeadZeadZdejfdYZeZedZdZdZdejfdYZeadeadZddZddZdejfdYZeadeadZdZdZdejfdYZeZe.jNee,jddZge_dZej:e(jZe.jNee,je_eaeaeeadZe.jNe=e,jde_eaeaeeaedZdej<fdYZe_eaeaeeeadZe_eadeedZe_eadeedZdejfdYZeZeZedZedZdZdZedZedZedZedZedZeZdZdZedZedZedZe.jNee,jddde.jNee,jddde.jNee,jddde.jNeSe,jddde.jNee,jddde.jNee,jddde.jNee,jdd$degedZeadZdZddZddZdefdYZdZdZdZdefdYZeZe.jNee,jddZeadZe_d$dZe_d$dZe_dZe_dZe_ddZdZe_dZe_dZdefdYZeadZdefdYZd$dZd$dZdefd YZead Zd efd YZiZead$ead ZdefdYZeZedegZdefdYZeZddZdZdefdYZeZe.jNee,je,jddddZdZddZdZeaedZDeaedZFe jdGdGfZe je jeeZ[defdYZddd$d Zd!efd"YZdd#Zd$Zead%Zd&Zd'Zead(d)Zd*efd+YZd,ejfd-YZdS(.sCA `Type` and `Op` classes to work with numpy.ndarrays symbolically.i(tabsolute_importtprint_functiontdivision(tbuiltinsN(t integer_types(txrange(tizip(tconfig(tgof(tApplytConstanttOptVariable(tGeneric(telemwise(t AsTensorErrortTensorVariabletTensorConstantt_tensor_py_operators(t TensorTypetvalues_eq_approx_always_true(t NoneConst(tscalar(tpartial(tcompiletprinting(tpprinttmin_informative_str(t RebroadcasttShapetshape(tgrad_undefined(tgrad_not_implemented(tDisconnectedType(tElemwiset DimShuffletCAReducetSumstheano.tensor.basicsrestructuredtext ent ShapeErrorcB`seZdZRS(s)Raised when the shape cannot be computed.(t__name__t __module__t__doc__(((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR&?scC`st|tjret|tjre|j|jkod|j|jkodtjt||dkSt|tjjrt|tjjrt dt |j |j DS||kSdS(su Return True iff x and y are equal. Checks the dtype and shape if x and y are numpy.ndarray instances. g|=cs`s*|] \}}tj||kVqdS(N(tnumpytall(t.0tatb((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pys PsN( t isinstanceR*tndarraytdtypeRR+tabstrandomt RandomStatet python_allRt __getstate__(txty((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytcheck_equal_numpyDs$$  cC`stj||S(swAdd `f` to :doc:`oplist`. Make `f` appear as a constructor in the oplist (`gen_oplist`, doc/oplist.txt). (t__oplist_constructor_listtappend(tf((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt constructor]s cC`s,t|dg}|j|||_dS(Nt __oplist_tags(tgetattrR;R>(tthingttagttags((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt __oplist_taghs cC`st|dr|jSt|tjrs|jjd krdt|j dkrdt d|n|j}nt|t rt|j t jrt|}nt|j tstd||j n|d kr|S|j j|krsgt|jD]}|j|s|^qd}|jtt|j|}|j|krot d||j n|S|j j|krt|d||j jS|Snt|ttfrtd|Dryt|SWqtt fk rqXnt|trtd nyt|d |d |SWnZtk ryt|}Wnt k rst!|}nXtd |t |nXd S(sReturn `x`, transformed into a `TensorType`. This function is often used by `make_node` methods of `Op` subclasses to turn ndarrays, numbers, `Scalar` instances, `Apply` instances and `TensorType` instances into valid input list elements. Parameters ---------- x : Apply instance, Variable instance, numpy.ndarray, or number This thing will be transformed into a `Variable` in a sensible way. An ndarray argument will not be copied, but a list of numbers will be copied to make an ndarray. name : str or None If a new `Variable` instance is created, it will be named with this string. ndim : None or integer Return a Variable with this many dimensions. Raises ------ ValueError If an `Apply` with more than one output is fetched or if `x` cannot be made into a Variable with `ndim` dimensions. AsTensorError If `x` cannot be converted to a TensorType Variable. t_as_TensorVariableisDIt is ambiguous which output of a multi-output Op has to be fetched.s)Variable type field must be a TensorType.is2TensorType could not be cast to have %i dimensionstn_onescs`s|]}t|tVqdS(N(R/R (R,txi((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pys ssCannot cast True or False as a tensor variable. Please use 1 or 0. This error might be caused by using the == operator on Variables. v == w does not do what you think it does, use theano.tensor.eq(v, w) instead.tnametndimsCannot convert %s to TensorTypeN("thasattrRDR/RR toptdefault_outputtNonetlentoutputst ValueErrorR ttypetscaltScalarttensor_from_scalarRRRHRt broadcastablet dimshuffletlisttranget shape_padleftttuplet python_anytstackt TypeErrortbooltconstanttstrt Exceptiontrepr(R7RGRHtidxtfirst_non_broadcastabletstr_x((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytas_tensor_variable~sZ '  "    c C`sJtj|d|}g|jD]}|dk^q}|dk rt||krstg|t||}n%t||krtd|nt||kstnyf|tkr|t d|j d||j d|}|S|t d|j d||d|SWn*t k rEt d|t|nXdS(sReturn a symbolic `Constant` with value `x`. Raises ------ TypeError `x` could not be converted to a numpy.ndarray. ValueError `x` could not be expanded to have ndim dimensions. R1is8ndarray could not be cast to constant with %i dimensionsRTRGs"Could not convert %s to TensorTypeN(RQtconvertRRLRMtTrueROtAssertionErrorRRR1tcopyR`R\RP( R7trtypeRGRHR1tx_tdt bcastabletrval((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytconstant_or_values* "      c C`st|dtd|d|d|}tjs1|S|j}|tkr|jjdkrd|jkoudknr|jt ks|jt ks|jt krt tdkr|t|g:0yE>cC`sd}d}t|j|ks6t|j|krEt}t}nEt|j|ksot|j|kr~t}t}n t}t}||fS(Ntfloat16tfloat32t complex64(R~(RR(R_R1t float16_atolt float16_rtolt float32_atolt float32_rtolt float64_atolt float64_rtol(R-R.ttinytnarrowtatoltrtol((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt_get_atol_rtolUs* * cC`sytj|}tj|}t||\}}|dk rH|}n|dk r]|}ntj||d|d|S(NRR(R*tasarrayRRLtallclose(R-R.RRtatol_trtol_((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt _allcloseds    tNotScalarConstantErrorcB`seZdZRS(sg Raised by get_scalar_constant_value if called on something that is not a scalar constant. (R'R(R)(((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRpstEmptyConstantErrorcB`seZdZRS(sj Raised by get_scalar_const_value if called on something that is a zero dimensional constant. (R'R(R)(((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRwscC`s|jdkrlt|jdks<tj|jdkrltjtjg|ks`tt nytj ||SWn t k rt d|nXdS(s Return a scalar stored in a numpy ndarray. Raises ------ NotScalarConstantError If the numpy ndarray is not a scalar. isDv.data is non-numeric, non-scalar, or has more than one unique valueN( RHRMRRtmaxR*R+tarrayRhRtcomplexR`R(Rs((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt numpy_scalar~s $   i c C`sH |}x; trC |dkr'tnt|tjttfrOtj|St|tj rqt |j St|t rt |jdddk r|jj}n |j}t |j S| r4 t |ddr4 |dkr4 |d8}t|jjttttjjtjfr5|jjd}q q4 t|jjtjjjr|jjj}|jjd}t|t rtj|jj|St|j dr1 |j j!|r1 tjdSq4 t|jjt"t#fr|jjd}q q4 t|jjtj$j%j&rg|jjdD]}t'|d|^q*} t(j)g| D]!}d|j*kos|dk^qUr1 |jjd}q q1 q4 t|jjt+j,rct|jjt+j-r|jj\} } | }q nt|jjt.r1 g|jjD]}t'|d|^q} dgg} |jjj/|j| | | ddj Sq4 t|jjt0r7t|jjj1t+j-r|jj\} } | }q q1 |r1 t|jjj1t.r1 g|jjD]}t'|d|^q} dgg} |jjj/|j| | | ddj Sq4 t|jjtj$j2j3r4 |j*dkr4 t|jjdt4rt5|jjj6|jj}y$|jjdjj7|j SWqt8k rt8t9t5|jjj:dt9|jjdjqXnt;|jjj:|jjdj*ksCt<|jjdjr^t|jjdjjt=r^t;|jjj:dkr^t>d|jjdjjdDrG|jjj:d}t|t?j@rt'|jjdd|}n|jjdjj|d} t'| d|} tjA| d |j jBSt>d |jjdjjdDro|jjj:d}t|t?j@rt'|jjdd|}nyd}tC}x`|jjdjjdD]D}tD|}|||kr|||}t}Pn||7}qW|r3w nWq[tEk rGq[tFk rWq[Xqon|jjdjrot|jjdjjtj$j%jGrot>d |jjdjjDrot;|jjj:dkro|jjj:d}t|t?j@rt'|jjdd|}ntH|}|jjdjj|} t'| d|} tjA| d |j jBS|j}|jd}|jr1 t|jjtj$jIr1 |j}|j:}|d}t|t?j@rt'|jdd|}n|jjd}|j j!}|j j*}|jr t|jjtr |jjdj!}gtJ||D]\}}|pq |^q\ }t5|}n|t;|ks t<|t;|ks d d d||f}tKjLdkr |dtM|7}n|dt9|7}tF|n||r. tjdSq1 q4 nt|q WdS(sReturn the constant scalar(0-D) value underlying variable `v`. If `v` is the output of dimshuffles, fills, allocs, rebroadcasts, cast, OutputGuard, DeepCopyOp, ScalarFromTensor, ScalarOp, Elemwise and some pattern with Subtensor, this function digs through them. If `v` is not some view of constant scalar data, then raise a NotScalarConstantError. Parameters ---------- elemwise : bool If False, we won't try to go into elemwise. So this call is faster. But we still investigate in Second Elemwise (as this is a substitute for Alloc) only_process_constants : bool If True, we only attempt to obtain the value of `orig_v` if it's directly constant and don't try to dig through dimshuffles, fills, allocs, and other to figure out its value. max_recur : int The maximum number of recursion. Notes ----- There may be another function similar to this one in the code, but I'm not sure where it is. t unique_valuetowneriiRTt max_recurs is not a valid index into cs`s|]}|jdkVqdS(iN(RH(R,tvar((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pys +sR1cs`s|]}|jdkVqdS(iN(RH(R,R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pys 7scs`s|]}|jdkVqdS(iN(RH(R,R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pys Tss#get_scalar_constant_value detected s&deterministic IndexError: x.shape[%d] swhen x.ndim=%d.thighs x=%sN(NRgRLRR/R*tintegerRtfloatRR0RRiR R?RARRsRRJtAllocR#RRtopst OutputGuardt DeepCopyOptinputsttheanotShape_itiRRIRPRTtScalarFromTensortTensorFromScalarttensortopttAsserttget_scalar_constant_valueRR+RHRQtScalarOptSecondt#get_scalar_constant_value_elemwisestperformR"t scalar_opt subtensort SubtensorRRYtget_constant_idxt __getitem__t IndexErrorR_tidx_listRMRhtJoinR5RtTypet_asarrayR1R|tget_vector_lengthR\ROt MakeVectortintRtzipRtexception_verbosityR( torig_vRtonly_process_constantsRtvRsRtinptctcondtshptvaltconstRztcdataRbtlengthtlooptjoinedtllRtleftmost_parentRJRt grandparenttgp_broadcastableRHtggp_broadcastabletb1tb2tltmsg((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs2        ,7 (    ( !$ $. !  ! !                    % cO`s(|jdd}t||d|S(NRG(tpopRLR(targstkwargsRG((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRscG`sLd}t|dkr(t||Sg|D]}t||^q/SdS(NcW`s|rSt|dtrS|dkr,|Sgt|dD]}|^q=Snt|trt|dkr|d}qnt|dkr||Sg|D]}||^qSdS(Nii(R/RRRYRM(R<tnamesRRG((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytf2s ' i(RMR(tfnsRR<((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt_multis  Rt complex128Rtfloat64tint8tint16tint32tint64cC`s1|dkrtj}nt|d}||S(sReturn a symbolic scalar variable. Parameters ---------- dtype: numeric None means to use theano.config.floatX. name A name to attach to this variable. N((RLRtfloatXR(RGR1RP((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs  cC`s4|dkrtj}nt|tf}||S(sReturn a symbolic vector variable. Parameters ---------- dtype: numeric None means to use theano.config.floatX. name A name to attach to this variable N(RLRRRR|(RGR1RP((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytvectors  cC`s7|dkrtj}nt|ttf}||S(sReturn a symbolic matrix variable. Parameters ---------- dtype: numeric None means to use theano.config.floatX. name A name to attach to this variable. N(RLRRRR|(RGR1RP((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytmatrixs  cC`s7|dkrtj}nt|ttf}||S(sReturn a symbolic row variable (ndim=2, broadcastable=[True,False]). Parameters ---------- dtype: numeric type None means to use theano.config.floatX. name A name to attach to this variable. N(RLRRRRgR|(RGR1RP((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytrows  cC`s7|dkrtj}nt|ttf}||S(sReturn a symbolic column variable (ndim=2, broadcastable=[False,True]). Parameters ---------- dtype : numeric None means to use theano.config.floatX. name A name to attach to this variable. N(RLRRRR|Rg(RGR1RP((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytcol2s  icC`s:|dkrtj}nt|tttf}||S(sReturn a symbolic 3-D variable. Parameters ---------- dtype: numeric type None means to use theano.config.floatX. name A name to attach to this variable. N(RLRRRR|(RGR1RP((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyttensor3Ms  icC`s=|dkrtj}nt|ttttf}||S(sReturn a symbolic 4-D variable. Parameters ---------- dtype: numeric type None means to use theano.config.floatX. name A name to attach to this variable. N(RLRRRR|(RGR1RP((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyttensor4js  icC`s@|dkrtj}nt|tttttf}||S(sReturn a symbolic 5-D variable. Parameters ---------- dtype: numeric type None means to use theano.config.floatX. name A name to attach to this variable. N(RLRRRR|(RGR1RP((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyttensor5s  c`sfd}|S(s Replace a symbol definition with an elementwise version of the corresponding scalar Op. If it is not None, the nfunc argument should be a string such that getattr(numpy, nfunc) implements a vectorized version of the elemwise operation. nin is the number of inputs expected by that function, and nout is the number of **destination** inputs it takes. That is, the function should take nin+nout inputs. nout == 0 means that the numpy function does not take a numpy array argument to put its result in. c `s@|j}|jd}|r'd}nd}d||f}|rtt|td }|jtjd}tj|idd6d|dof}n9tt|}tj|d|dof}t|dt r|j d |j |_ n||_ d |_ t j|tj||S( Nt_inplacetinplacet no_inplacesElemwise{%s,%s}iRGt nfunc_specR)s R(R'tendswithR?RQRMt __class__t transfer_typeRR"R|R)t__epydoc_asRoutineR(RtassignRtFunctionPrinter(tsymbolt symbolnameRRtnRtinplace_scalar_opRn(tnfunctnintnout(s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt constructs(    ((RRRR((RRRs3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt_scal_elemwise_with_nfuncs cC`s*yt|SWntk r%|gSXdS(sP Convert x to a list if it is an iterable, otherwise wrap it in a list. N(RVR\(R7((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt_packs RcB`s2eZdZdZdZdZdZRS(cC`sFt|jtjstt||gtd|jjddgS(NR1RT((R/RPRQRRRhR RR1(tselfts((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt make_nodes cC`s)|\}|\}tj||dsR1RR'i(RLRYRWRHRRR*RRNR1Rt transposet concatenateRRMtprodtreshapeR*(RRRtoutstparamsR7taxesRtmax_idxRt keep_axest transposed_xt kept_shapet reduced_shapet new_shapet reshaped_x((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs"   4 !c C`s~t|jdkrCt|j|jdjkrCtdn|d}|d}|\}} |d} d} | tS(NiisGNumPy C-API can compute max and argmax only for 1 axis or for all axes.R5Rs #if PY_MAJOR_VERSION >= 3 #ifndef PyInt_AS_LONG #define PyInt_AS_LONG PyLong_AS_LONG #endif #endif int axis; if (PyTuple_GET_SIZE(%(axis)s) == PyArray_NDIM(%(x)s)) { axis = NPY_MAXDIMS; } else if(PyTuple_GET_SIZE(%(axis)s) == 1) { PyObject* axis_object = PyTuple_GET_ITEM(%(axis)s, 0); axis = (int)PyInt_AS_LONG(axis_object); if (axis > PyArray_NDIM(%(x)s)-1 || axis < -PyArray_NDIM(%(x)s)) { PyErr_SetString(PyExc_ValueError, "MaxAndArgmax: bad axis argument"); %(fail)s } } else { PyErr_SetString(PyExc_NotImplementedError, "MaxAndArgmax: NumPy C-API can compute max and argmax only for 1 axis or for all axes."); %(fail)s } Py_CLEAR(%(max)s); Py_CLEAR(%(argmax)s);//todo pass them as out parameter. %(max)s = (PyArrayObject*)PyArray_Max(%(x)s, axis, NULL); if (%(max)s == NULL) { %(fail)s; } if (!PyArray_CheckExact(%(max)s)) { %(max)s = (PyArrayObject*)PyArray_FromAny((PyObject*)%(max)s, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL); if(%(max)s == NULL){ %(fail)s; } } %(argmax)s = (PyArrayObject*)PyArray_ArgMax(%(x)s, axis, NULL); if (%(argmax)s == NULL) { Py_CLEAR(%(max)s); %(fail)s; } if (!PyArray_CheckExact(%(argmax)s)) { %(argmax)s = (PyArrayObject*)PyArray_FromAny((PyObject*)%(argmax)s, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL); if(%(argmax)s == NULL){ %(fail)s; } } if (PyArray_TYPE(%(argmax)s) != NPY_INT64) { PyObject * tmp = PyArray_Cast(%(argmax)s, NPY_INT64); if (NULL == tmp){ %(fail)s; } Py_DECREF(%(argmax)s); %(argmax)s = (PyArrayObject*)tmp; } (RMR'RRHR R( RRRGRRRR7R'RR*RRz((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs4    ;cC`sdS(Ni(i((R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR sc`sF|dtfdt|jdjjD}||gS(Nic3`s.|]$\}}|jkr|VqdS(N(R'(R,RR.(tishapeR(s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pys %s (RYR-RRPRT(RRtshapesRn((R>Rs3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR#s cC`s|ddkrddgSt|jdkr>tdn|jddkr`tdn|djdkrtdn|j|j\}}|jddkr|d|t|djdfdgS|dt|djd|fdgSdS(Niis-R_op supported for arg_max only for one axis!s4R_op supported for arg_max only when axis is 0 or 1is7R_op supported for arg_max only when input is a matrix( RLRMR'RORHRRNtarangeR(RRRtmax_valstmax_pos((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR)s  cC`s|d}t|j}|\}}t|jt}t|jt}|rk|rkttgS|r~|jgStj|rtt |j } n|} t || } g} d} tj|rd}nxYt |j D]H} |dks| |jkr| jdq| j| | d7} qWt|j| |}t| j| | }t|||}|fS(NiR7i(R+R'R/RPR!RRtequalsRVRWRHRRLRRsR;R#RTteq(RRR R7R'tg_maxt g_max_idxtg_max_disconnectedtg_max_idx_disconnectedtaxis_txmaxtpatterntout_dimRt g_max_padtxmax_padtg_x((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR =s4      (saxis(R'R(R)RRtE_axisR t params_typeRR(R)RRRRRRR (((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR&s     D   tArgmaxcB`s_eZdZdZdZdZd Zd dZdZ dZ dZ dZ d Z RS( sB Calculate the argmax over a given axis or over all axes. iis invalid axisc C`st|}t|ttjfr6t|g}nt|tjri|jdkrit|g}n\t|tt tjfrg|D]}t|^q}|t t |j jkrd}qnt|t rtj|rd}qt|tstd|q|jtks+tt|jttjfsmt|jtjr|jjdkrt|jg}qt|jt tjfrg|jD]}t|^q}qnt|t r'xCtt|D]/}||dkr||c|j j7sR1RR'ii(RLRYRWRHR*RR0R1RRMR2R3RRR*(RRRR4R7R6R7RR8R9R:R;R<R=((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs   4 c C`s|\}}|\}|d} tj|jdr>d} nQ|jdjdksZtt|jdjdkrtndt} d} | tS(NRisaxis = NPY_MAXDIMS;s" axis = ((dtype_%(axis)s*)PyArray_DATA(%(axis)s))[0]; if(axis > PyArray_NDIM(%(x)s)-1 || axis < -PyArray_NDIM(%(x)s)){ PyErr_SetString(PyExc_ValueError, "Argmax, bad axis argument"); %(fail)s } s int axis; Py_CLEAR(%(argmax)s);//todo pass them as out parameter. %(axis_code)s %(argmax)s = (PyArrayObject*)PyArray_ArgMax(%(x)s, axis, NULL); if(%(argmax)s == NULL){ %(fail)s; } if(!PyArray_CheckExact(%(argmax)s)){ %(argmax)s = (PyArrayObject*)PyArray_FromAny((PyObject*)%(argmax)s, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL); if(%(argmax)s == NULL){ %(fail)s; } } if(PyArray_TYPE(%(argmax)s) != NPY_INT64){ PyObject * tmp = PyArray_Cast(%(argmax)s, NPY_INT64); if (NULL == tmp){ %(fail)s; } Py_DECREF(%(argmax)s); %(argmax)s = (PyArrayObject*)tmp; } ( RRCRRHRhRMRsR R( RRRGRRRR7R'R*Rt axis_codeRz((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs      cC`sdS(Ni(i((R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRsc C`s|\}}|jd}|jdkr/dgStgt|jdjjD]%\}}||jkrL||^qL}|gS(Nii((RRsRLRYR-RPRT( RRR?R>t axis_shapeR'RR.Rn((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs   BcC`s1|\}}t|d|d}|j|gS(NisNargmax is not defined for non-integer axes so argmax(x, axis+eps) is undefined(RR(RRR R7R't axis_grad((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR  s    (N(R'R(R)RRRPRRLRRRRRR (((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRRts <  .  c C`st|}t|}|dkr?tt|jj}nvt|ttj frc|g}nRt|tj r|jdkrt |g}ng|D]}t |^q}g}xX|D]P}t|tst dn|dkr||jj7}n|j |qWd}g}xSt|jjD]?\}}||kr]|j dq5|j ||d7}q5Wt|jj||S(s Reintroduces in y with length one the axes of x which have been left out in a prior reduction of x. With this option, the resulting tensor will broadcast correctly against the original tensor x. is3keepdims option can be used only with constant axisR7iN(ReRLRVRWRPRHR/RR*RR0RROR;R-RTR#( R7R8R'R-tnewaxisRtnew_dimstjt_((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt makeKeepDimss2    !     cC`st|}|dkr3tt|jj}nt|ttj fslt|tj r~|jdkr~t |g}nGt|t ttj frg|D]}t |^q}n t|t rtj|rtt|jj}qt|tstd|q|jtks+tt|jttj fsmt|jtj r|jjdkrt |jg}qt|jttj frg|jD]}t |^q}qnt|dkrtt|jj}nxtt|D]x}||dkr4||c|jj7 bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytgtscC`sdS(sa <= bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytlescC`sdS(sa >= bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytgescC`sdS(sa == bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRD scC`sdS(sa != bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytneq%scC`sdS(sisnan(a)N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytisnan*scC`sdt|}|jtkrZttjtddgt|jD]}|j |^q@St |S(sisnan(a)R1R]( ReR1RtallocR*RR|RWRHRtisnan_(R-R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRm3s  *cC`sdS(sisinf(a)N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytisinf<scC`sdt|}|jtkrZttjtddgt|jD]}|j |^q@St |S(sisinf(a)R1R]( ReR1RRnR*RR|RWRHRtisinf_(R-R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRpFs  *cC`stt|||||S(s Implement Numpy's ``allclose`` on tensors. ``absolute(a - b) <= (atol + rtol * absolute(b))`` Parameters ---------- a : tensor Input to compare. b : tensor Input to compare. rtol : float The relative tolerance parameter. atol : float The absolute tolerance parameter. equal_nan: bool Whether to consider nan's in the same place to be close. Returns ------- bool A boolean value (of type int8 returned by the tensor elementwise `all` function) whether all elements in a and b are in the tolerance range defined above. Notes ----- Not a symmetric equation. See Numpy's documentation. (R+tisclose(R-R.RRt equal_nan((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyROscC`st||}||t|}t||}t|}t|} t|| } t|} t|} t| | } t| | }t|t|}t| | }t| t|| t|}t||}t||}|rt|| }t||S|SdS(s# Implements Numpy's ``isclose`` on tensors. The tolerance values are positive, typically very small numbers. The relative difference (`rtol` * abs(`b`)) and the absolute difference `atol` are added together to compare against the absolute difference between `a` and `b`. ``absolute(a - b) <= (atol + rtol * absolute(b))`` Parameters ---------- a : tensor Input to compare. b : tensor Input to compare. rtol : float The relative tolerance parameter. atol : float The absolute tolerance parameter. equal_nan : bool Whether to consider nan's in the same place to be close Returns ------- int8 A boolean (int8) array where two arrays are element-wise equal within a tolerance. Notes ----- Not a symmetric equation. See Numpy's documentation. Examples -------- >>> import theano >>> import numpy as np >>> a = theano._asarray([1e10, 1e-7], dtype="float64") >>> b = theano._asarray([1.00001e10, 1e-8], dtype="float64") >>> theano.tensor.isclose(a, b).eval() array([1, 0], dtype=int8) >>> a = theano._asarray([1e10, 1e-8], dtype="float64") >>> b = theano._asarray([1.00001e10, 1e-9], dtype="float64") >>> theano.tensor.isclose(a, b).eval() array([1, 1], dtype=int8) >>> a = theano._asarray([1e10, 1e-8], dtype="float64") >>> b = theano._asarray([1.0001e10, 1e-9], dtype="float64") >>> theano.tensor.isclose(a, b).eval() array([0, 1], dtype=int8) >>> a = theano._asarray([1.0, np.nan], dtype="float64") >>> b = theano._asarray([1.0, np.nan], dtype="float64") >>> theano.tensor.isclose(a, b).eval() array([1, 0], dtype==int8) >>> a = theano._asarray([1.0, np.nan], dtype="float64") >>> b = theano._asarray([1.0, np.nan], dtype="float64") >>> theano.tensor.isclose(a, b, equal_nan=True).eval() array([1, 1], dtype==int8) >>> a = theano._asarray([1.0, np.inf], dtype="float64") >>> b = theano._asarray([1.0, -np.inf], dtype="float64") >>> theano.tensor.isclose(a, b).eval() array([1, 0], dtype==int8) >>> a = theano._asarray([1.0, np.inf], dtype="float64") >>> b = theano._asarray([1.0, np.inf], dtype="float64") >>> theano.tensor.isclose(a, b).eval() array([1, 1], dtype==int8) N( R2RjRmt bitwise_orRpt bitwise_andt bitwise_notRDtsgn(R-R.RRRstdifft tolerancet close_prelimta_nantb_nantnansta_inftb_inftinfst nans_or_infstcloset both_infst inf_signs_eqtinf_eqtclose_with_infst both_nans((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRrqs&F    # cC`sdS(sif cond then ift else iffN((Rtifttiff((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRescC`sdS(s bitwise a & bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytand_scC`sdS(s bitwise a | bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytor_scC`sdS(s bitwise a ^ bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytxorscC`sdS(s bitwise ~aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytinvertscC`sdS(s|`a`| TensorVariable overloads the `TensorVariable.__abs__` operator so that this function is called when you type abs(a). N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytabs_ss|%(0)s|icC`sdS(se^`a`N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytexpscC`sdS(s2^`a`N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytexp2scC`sdS(s e^`a` - 1N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytexpm1scC`sdS(s-aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytneg scC`sdS(s1.0/aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytinv'scC`sdS(sbase e logarithm of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytlog,scC`sdS(sbase 2 logarithm of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytlog21scC`sdS(sbase 10 logarithm of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytlog106scC`sdS(slog(1+a)N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytlog1p;scC`sdS(s sign of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRw@scC`sdS(s ceiling of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytceilEscC`sdS(s floor of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytfloorJscC`sdS(s trunc of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyttruncOscC`stt||dS(scast(round(a,mode),'int64')R(R%tround(R-tmode((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytiroundTscC`sq|dkr1d}tjjr1tjdq1n|dkrGt|S|dkr]t|Std|dS(s\round_mode(a) with mode in [half_away_from_zero, half_to_even]. Default to half_to_even.t half_to_evenstheano.tensor.round() changed its default from `half_away_from_zero` to `half_to_even` to have the same default as NumPy. Use the Theano flag `warn.round=False` to disable this warning.thalf_away_from_zeros!round mode %s is not implemented.N(RLRtwarnRtwarningstround_half_away_from_zerotround_half_to_evenR`(R-R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRZs       cC`sdS(sround_half_to_even(a)N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRnscC`sdS(sround_half_away_from_zero(a)N((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRsscC`sdS(s square of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytsqrxscC`sdS(ssquare root of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytsqrtscC`sdS(sconvert degree a to radianN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytdeg2radscC`sdS(sconvert radian a to degreeN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytrad2degscC`sdS(s cosine of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytcosscC`sdS(sarccosine of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytarccosscC`sdS(s sine of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytsinscC`sdS(s arcsine of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytarcsinscC`sdS(s tangent of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyttanscC`sdS(sarctangent of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytarctanscC`sdS(sarctangent of a / bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytarctan2scC`sdS(shyperbolic cosine of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytcoshscC`sdS(shyperbolic arc cosine of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytarccoshscC`sdS(shyperbolic sine of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytsinhscC`sdS(shyperbolic arc sine of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytarcsinhscC`sdS(shyperbolic tangent of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyttanhscC`sdS(shyperbolic arc tangent of aN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytarctanhscC`sdS(serror functionN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyterfscC`sdS(scomplementary error functionN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyterfcscC`sdS(s#scaled complementary error functionN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyterfcxscC`sdS(sinverse error functionN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyterfinvscC`sdS(s$inverse complementary error functionN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyterfcinvscC`sdS(sgamma functionN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytgammascC`sdS(slog gamma functionN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytgammalnscC`sdS(s derivative of log gamma functionN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytpsiscC`sdS(schi squared survival functionN((R7tk((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytchi2sfscC`sdS(s Bessel function of the 0'th kindN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytj0scC`sdS(s Bessel function of the 1'th kindN((R-((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytj1 scC`sdS(s2Return real component of complex-valued tensor `z`N((R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytreal scC`sdS(s7Return imaginary component of complex-valued tensor `z`N((R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytimag scC`sdS(s:Return polar-coordinate angle of complex-valued tensor `z`N((R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytangle scC`sdS(s>Return complex-valued tensor with `real` and `imag` componentsN((RR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR scC`sdS(s$Return the complex conjugate of `z`.N((R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytconj scC`sdS(sAReturn complex-valued tensor from polar coordinate specification.N((R2R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytcomplex_from_polar# scC`sdS(s0Create a matrix by filling the shape of a with bN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytsecond. stfillcC`sV|dkr|jj}ntdd|}|rI|j|jkrI|St||S(sequivalent of numpy.ones_like Parameters ---------- model : tensor dtype : data-type, optional opt : If True, we will return a constant instead of a graph when possible. Useful for Theano optimization, not for user building a graph as this have the consequence that model isn't always in the graph. Returns ------- tensor tensor the shape of model containing ones of the type of dtype. g?R1N(RLRPR1R^R(tmodelR1RRz((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt ones_like6 s  cC`sV|dkr|jj}ntdd|}|rI|j|jkrI|St||S(sequivalent of numpy.zeros_like Parameters ---------- model : tensor dtype : data-type, optional opt : If True, we will return a constant instead of a graph when possible. Useful for Theano optimization, not for user building a graph as this have the consequence that model isn't always in the graph. Returns ------- tensor tensor the shape of model containing zeros of the type of dtype. gR1N(RLRPR1R^R(RR1RRz((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRN s  cC`sXt|tttfs$|g}n|dkr<tj}nttj dd||S(sU Create a Tensor filled with zeros, closer to Numpy's syntax than ``alloc``. iR1N( R/RVRYRRLRRRnR*R(RR1((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytzerosg s    cC`sXt|tttfs$|g}n|dkr<tj}nttj dd||S(sT Create a Tensor filled with ones, closer to Numpy's syntax than ``alloc``. iR1N( R/RVRYRRLRRRnR*R(RR1((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytonesr s    tNonzerocB`s/eZdZdZdZdZdZRS(s Return the indices of the elements that are non-zero. Returns a matrix of shape (ndim, number of nonzero elements) such that element (i,j) is the index in the ith dimension of the jth non-zero element. Note this is different than NumPy, which returns a tuple of arrays, one for each dimension of the input array. Parameters ---------- a : array_like Input array. Returns ------- matrix Matrix containing the indices of the non-zero elements of a. See Also -------- nonzero_values : Return the non-zero elements of the input array flatnonzero : Return the indices of the non-zero elements of the flattened input array. cC`sat|}|jdkr*tdntdddttfg}tj||g|S(Nis(Nonzero only supports non-scalar arrays.R1RRT(ReRHRORR|RR (RR-toutput((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR s  !cC`s||d}|\}tj|}t|ddkrJtj|}ntjt|df}|jd|deZdZddZdZdZdZdZRS(R1cC`s%|dkrtj}n||_dS(N(RLRRR1(RR1((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(' s  c C`s^t|}t|}t|}tj||||gtd|jdttfgS(NR1RT(ReRR RR1R|(RtNtMR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR, s    cC`s>|\}}}|\}tj|||d|j|d s(sdtypeN( R'R(RRLR(RRRR (((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR# s    cC`sI|dkrtj}n|dkr-|}nt|}||||S(s An array with ones at and below the given diagonal and zeros elsewhere. Parameters ---------- N : int Number of rows in the array. M : int, optional Number of columns in the array. By default, `M` is taken equal to `N`. k : int, optional The sub-diagonal at and below which the array is filled. `k` = 0 is the main diagonal, while `k` < 0 is below it, and `k` > 0 is above. The default is 0. dtype : dtype, optional Data type of the returned array. The default is float. Returns ------- Array of shape (N, M) Array with its lower triangle filled with ones and zero elsewhere; in other words ``T[i,j] == 1`` for ``i <= j + k``, 0 otherwise. N(RLRRR(RRRR1RJ((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRB s      cC`s.|t|jd|jdd|d|jS(s1 Lower triangle of an array. Return a copy of an array with elements above the `k`-th diagonal zeroed. Parameters ---------- m : array_like, shape (M, N) Input array. k : int, optional Diagonal above which to zero elements. `k = 0` (the default) is the main diagonal, `k < 0` is below it and `k > 0` is above. Returns ------- array, shape (M, N) Lower triangle of `m`, of same shape and data-type as `m`. See Also -------- triu : Same thing, only for the upper triangle. iiRR1(RRR1(tmR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyttrilc sc C`s6|dt|jd|jdd|dd|jS(s Upper triangle of an array. Return a copy of a matrix with the elements below the `k`-th diagonal zeroed. Please refer to the documentation for `tril` for further details. See Also -------- tril : Lower triangle of an array. iiRR1(RRR1(RR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyttriu~ stEyecB`s>eZdZddZdZdZdZdZRS(R1cC`s%|dkrtj}n||_dS(N(RLRRR1(RR1((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR( s  c C`st|}t|}t|}|jdks9t|jdksNt|jdkscttj||||gtd|jdttfgS(NiR1RT(ReRHRhRR RR1R|(RRRR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR s    cC`s>|\}}}|\}tj|||d|j|d' sR"(R'RLtjoin(R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt__str__% scC`sdS(NR((Rtidtype((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt _output_dtype+ scC`sc|\}|\}|jdkr*d}n |jd}tjtj|ddd||d    !        c C`sXt|trtdnttd|d|d|d|d|}d|_|S(s Computes the standard deviation along the given axis(es) of a tensor `input`. Parameters ---------- axis: None or int or (list of int) (see `Sum`) Compute the variance along this axis of the tensor. None means all axes (like numpy). ddof: Degrees of freedom; 0 would compute the ML estimate, 1 would compute the unbiased estimate. keepdims : bool If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the original tensor. corrected : bool If this is set to True, the 'corrected_two_pass' algorithm is used to compute the variance. Refer : http://www.cs.yale.edu/publications/techreports/tr222.pdf Notes ----- It calls 'var()' and 'var()' uses the two-pass algorithm (reference below). https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Two-pass_algorithm Function 'var()' also supports 'corrected_two_pass' algorithm (using the 'corrected' flag) which is numerically more stable. There exist other implementations that offer better stability, but probably slower. s{Parameter keepdims is now at index 3: (input, axis=None, ddof=0, keepdims=False, corrected=False)RR'R-R^R.tstd(R/R]RORRRG(RR'R-R^R.Rz((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR5 s  tDefaultcB`s6eZdZidgd6ZdZdZdZRS(s Takes an input x and a default value. If the input is not None, a reference to it is returned. If the input is None, a copy of the default value is returned instead. The input and the default must have exactly the same type. icC`sbt|t|}}|j|jkr@td||ntj|||g|jgS(Ns,Both default() arguments must have same type(ReRPR\RR (RR7tdefault((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR, s cC`sB|\}}|\}|dkr4|j|d scC`sdS(selementwise moduloN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRH scC`sdS(selementwise powerN((R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytpow scC`sdS(s Clip x to be between min and max. Notes ----- When `x` is equal to the boundaries, the output is considered to be `x`, so at these points, the gradient of the cost wrt the output will be propagated to `x`, not to `min` nor `max`. In other words, on these points, the gradient wrt `x` will be equal to the gradient wrt the output, and the gradient wrt `min` and `max` will be zero. N((R7RcR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytclip st+iteithert*it-tleftt/s//s**trightcC`syt|||}Wntk r)nXt|tjsQt|tjjr|jrt|jjt r|jj d}qt |}n|S(s This function is basically a call to tensor.get_scalar_constant_value. The main difference is the behaviour in case of failure. While get_scalar_constant_value raises an TypeError, this function returns x, as a tensor if possible. If x is a ScalarVariable from a scalar_from_tensor, we remove the conversion. If x is just a ScalarVariable, we convert it to a tensor with tensor_from_scalar. i( RRR/RQtScalarVariablet sharedvartScalarSharedVariableRRJRRRS(R7RR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytextract_constant s   cC`s|dkr.tt|jddd}nt|j||}|jr|tt|jdddkr|jd|_n|S(s Reorder the dimensions of x. (Default: reverse them) This is a macro around dimshuffle that matches the numpy.transpose function. iis.TN(RLRVRWRHR#RTRG(R7R6Rz((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR0 s  ".cC`s0t|t|}}|jdkr7tdn|jdkrUtdn|jdkr|jdgdg|jd|S|jdkr||jdgdg|jdS|jdks|jdkrt|||jdgtjd|jdggStjj j ||SdS( s7 Compute the batched dot product of two variables: batched_dot(a, b)[i] = dot(a[i], b[i]) Note that this batched_dot function does one of three things, in the following sequence: 1. If either a or b is a vector, it returns the batched elementwise product without calling the Theano BatchedDot op. 2. If both a and b have either 2 or 3 dimensions, it calls Theano's BatchedDot op on a and b. 3. If either a or b has more than 3 dimensions, it calls Theano's batched_tensordot function with appropriate axes. The batched_tensordot function expresses high-dimensional batched dot products in terms of batched matrix-matrix dot products, so it may be possible to futherize optimize for performance. is%a must have at least one (batch) axiss%b must have at least one (batch) axisiR7iiN( ReRHR\RUtbatched_tensordotR*RaRRR t BatchedDot(R-R.((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt batched_dot s&&3icC`st|||dtdtS(s Compute a batched tensordot product. A hybrid of batched_dot and tensordot, this function computes the tensordot product between the two tensors, by iterating over the first dimension to perform a sequence of tensordots. Parameters ---------- x : tensor A Tensor with sizes e.g.: for 3D (dim1, dim3, dim2) y : tensor A Tensor with sizes e.g.: for 3D (dim1, dim2, dim4) axes: int or array-like of length 2 If an integer, the number of axes to sum over. If an array, it must have two array elements containing the axes to sum over in each tensor. If an integer i, it is converted to an array containing the last i dimensions of the first tensor and the first i dimensions of the second tensor (excluding the first (batch) dimension): axes = [list(range(a.ndim - i, b.ndim)), list(range(1,i+1))] If an array, its two elements must contain compatible axes of the two tensors. For example, [[1, 2], [2, 4]] means sum over the 2nd and 3rd axes of a and the 3rd and 5th axes of b. (Remember axes are zero-indexed!) The 2nd axis of a and the 3rd axis of b must have the same shape; the same is true for the 3rd axis of a and the 5th axis of b. Like tensordot, this function uses a series of dimshuffles and reshapes to reduce the tensor dot product to a matrix or vector dot product. Finally, it calls batched_dot to compute the result. tdottbatched(t_tensordot_as_dotRXRg(R7R8R6((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRVs$cC`st|}||||S(N(tSplit(R7t splits_sizetn_splitsR't the_split((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytsplitCs R\cB`steZdZd Zd ZdZdZdZdZ dZ dZ dZ d Z d Zd ZRS(sPartition a `TensorVariable` along some axis. Examples -------- >>> x = vector() >>> splits = lvector() You have to declare right away how many split_points there will be. >>> ra, rb, rc = split(x, splits, n_splits = 3, axis = 0) >>> f = function([x, splits], [ra, rb, rc]) >>> a, b, c = f([0,1,2,3,4,5], [3, 2, 1]) a == [0,1,2] b == [3, 4] c == [5] t len_splitscC`st||_dS(N(RRa(RRa((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(_scC`s|jjd|jS(Ns{%s}(RR'Ra(R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR%bscC`st|}t|}t|}|jtkrHtd|jn|jtkrltd|jn|||g}gt|jD]}|j^q}t|||S(tWRITEMEs$splits must have type tensor.lvectorsaxis must have type lscalar(ReRPtint_vector_typesR\t int_typesRRaR (RR7R'tsplitsRRRN((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRes   (cC`s|\}}}tjdd!d krC|jdkrCt|}ny|j|}Wn td||jfnXt||jkrtdt||jfntj ||krtdtj ||fnt g|D]}|dk^qrtdng|jD]} t d d d ^q"} d} xdt |jD]S} | || } t | | d | |<|jt| j|| d<| } qVWd S( Rbiiiis;Split.perform() with axis=(%s) is invalid for x.shape==(%s)s.In Split.perform(), len(splits) != len_splits.s!The splits sum to %s, expected %ssGSplit: you tried to make an ndarray with a negative number of elements.N(ii(tsyst version_infoRtRRRORMRaR*RRZtsliceRLRRRYRi(RRRRNR7R'Retlen_along_axistnbRt general_keyt lower_idxRt upper_idx((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR|s.%%(#c C`s|jd}|jd}|\}}}g}xyt|jD]h} t|} tjjj| ||| } gtt|D]} | | ^q} |j | q?W|S(Nii( RRRaReRRRt set_subtensorRMR;( RRRR'Retshp_xtshp_axist shp_splitst out_shapesRttemp((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs    )c C`s|\}}}||tdt}tg|D]}t|jt^q1r}tt|d|t|d|gSg}xRt||D]A\} }t|jtr|j| j q|j|qWt ||t|d|t|d|gS(s;Join the gradients along the axis that was used to split x.Rii( RRgR5R/RPR!RRR;RR$( RRt g_outputsR7R'RRNtgt new_g_outputsto((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR s%  cC`sE|ddkr*g|jD] }d^qS|j|d|djS(Nii(RLRaRRN(RRRR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRscC`sdS(Ni(i((R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRscC`sdS(Ns\ /* Return 1 if output has the correct shape. */ int split_output_shape_is_correct ( PyArrayObject* output, PyArrayObject* array_to_split, int axis_to_split, npy_intp split_size ) { return PyArray_NDIM(output) == PyArray_NDIM(array_to_split) && memcmp( PyArray_DIMS(output), PyArray_DIMS(array_to_split), axis_to_split * sizeof(npy_intp) ) == 0 && memcmp( PyArray_DIMS(output) + axis_to_split + 1, PyArray_DIMS(array_to_split) + axis_to_split + 1, (PyArray_NDIM(array_to_split) - axis_to_split - 1) * sizeof(npy_intp) ) == 0 && split_size == PyArray_DIM(output, axis_to_split); } ((R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytc_support_codescC`s|jdkrdSddj|}|\}}} |d} tj|jdjj} tj|jdjj} |jdjjd} |jdjjd}|j}dt S( Nitt&s, &Riis int ndim = PyArray_NDIM(%(x)s); int axis = (int)(*(%(axis_dtype)s*)PyArray_GETPTR1(%(axis)s, 0)); int splits_count = PyArray_DIM(%(splits)s, 0); npy_intp len_along_axis, sum_of_splits = 0, current_split_length = 0, current_split_start = 0; npy_intp* split_dims = NULL; PyObject* split_view = NULL; npy_intp data_offset; int i; PyArrayObject** outputs[] = {%(outputs_pointers)s}; /* Check inputs. */ if (splits_count != %(expected_splits_count)s) { PyErr_Format(PyExc_ValueError, "Split: splits count (%%d) != expected count (%%d).", splits_count, %(expected_splits_count)s); %(fail)s } if (axis < 0) { axis += ndim; } if (axis < 0 || axis >= ndim) { PyErr_Format(PyExc_IndexError, "Split: invalid axis %%d for a %%d-D array.", axis, ndim); %(fail)s } len_along_axis = PyArray_DIM(%(x)s, axis); for (i = 0; i < splits_count; ++i) { current_split_length = (npy_intp)(*(%(splits_dtype)s*)PyArray_GETPTR1(%(splits)s, i)); if (current_split_length < 0) { PyErr_Format(PyExc_ValueError, "Split: you try to take a negative number (%%ld) of elements.", current_split_length); %(fail)s } sum_of_splits += current_split_length; } if (sum_of_splits != len_along_axis) { PyErr_Format(PyExc_ValueError, "Split: the splits sums to %%ld, expected %%ld.", sum_of_splits, len_along_axis); %(fail)s } /* Check outputs. */ split_dims = (npy_intp*) malloc(ndim * sizeof(npy_intp)); if (split_dims == NULL) { PyErr_NoMemory(); %(fail)s } memcpy(split_dims, PyArray_DIMS(%(x)s), ndim * sizeof(npy_intp)); for (i = 0; i < splits_count; ++i) { PyArrayObject** output = outputs[i]; current_split_length = (npy_intp) (* (%(splits_dtype)s*) PyArray_GETPTR1(%(splits)s, i)); if (*output == NULL || !split_output_shape_is_correct(*output, %(x)s, axis, current_split_length)) { Py_XDECREF(*output); split_dims[axis] = current_split_length; *output = (PyArrayObject*)PyArray_EMPTY(ndim, split_dims, %(x_typenum)s, PyArray_IS_F_CONTIGUOUS(%(x)s)); if (outputs == NULL) { PyErr_SetString(PyExc_RuntimeError, "Split: unable to allocate an output."); free(split_dims); %(fail)s } } } /* Compute split. */ for (i = 0; i < splits_count; ++i) { current_split_length = (npy_intp) (* (%(splits_dtype)s*) PyArray_GETPTR1(%(splits)s, i)); data_offset = PyArray_STRIDE(%(x)s, axis) * current_split_start; split_dims[axis] = current_split_length; split_view = PyArray_New(&PyArray_Type, ndim, split_dims, %(x_typenum)s, PyArray_STRIDES(%(x)s), PyArray_BYTES(%(x)s) + data_offset, %(x_itemsize)s, PyArray_FLAGS(%(x)s), NULL); if (split_view == NULL) { PyErr_SetString(PyExc_RuntimeError, "Split: unable to create a view for a split."); free(split_dims); %(fail)s } if (PyArray_CopyInto(*outputs[i], (PyArrayObject*)split_view) != 0) { PyErr_SetString(PyExc_RuntimeError, "Split: unable to copy a split view into the output."); Py_XDECREF(split_view); free(split_dims); %(fail)s } Py_XDECREF(split_view); current_split_start += current_split_length; } free(split_dims); ( RaR$R*R1RtnumtitemsizeRPt dtype_specsR(RRRGRRNRtoutputs_pointersR7R'ReRt x_typenumt x_itemsizet axis_dtypet splits_dtypetexpected_splits_count((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs  cN(s len_splits(R'R(R)RLRaRR(R%RRRR RRRxR(((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR\Hs    $    cG`s>tg|D]}|tf^q |}tjjj|S(s" Make the input broadcastable in the specified axes. For example, addbroadcast(x, 0) will make the first dimension of x broadcastable. When performing the function, if the length of x along that dimension is not 1, a ValueError will be raised. We apply the opt here not to pollute the graph especially during the gpu optimization Parameters ---------- x : tensor_like Input theano tensor. axis : an int or an iterable object such as list or tuple of int values The dimension along which the tensor x should be broadcastable. If the length of x along these dimensions is not 1, a ValueError will be raised. Returns ------- tensor A theano tensor, which is broadcastable along the specified dimensions. (RRgRRRtapply_rebroadcast_opt(R7R6R'Rn((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt addbroadcastSs+cG`s>tg|D]}|tf^q |}tjjj|S(s0 Make the input impossible to broadcast in the specified axes. For example, addbroadcast(x, 0) will make the first dimension of x broadcastable. When performing the function, if the length of x along that dimension is not 1, a ValueError will be raised. We apply the opt here not to pollute the graph especially during the gpu optimization Parameters ---------- x : tensor_like Input theano tensor. axis : an int or an iterable object such as list or tuple of int values The dimension along which the tensor x should be unbroadcastable. If the length of x along these dimensions is not 1, a ValueError will be raised. Returns ------- tensor A theano tensor, which is unbroadcastable along the specified dimensions. (RR|RRRR(R7R6R'Rn((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt unbroadcastqs+cC`sNtgtt|D]}|||f^q|}tjjj|S(sH Make the input adopt a specific broadcasting pattern. Broadcastable must be iterable. For example, patternbroadcast(x, (True, False)) will make the first dimension of x broadcastable and the second dimension not broadcastable, so x will now be a row. We apply the opt here not to pollute the graph especially during the gpu optimization. Parameters ---------- x : tensor_like Input theano tensor. broadcastable : an iterable object such as list or tuple of bool values A set of boolean values indicating whether a dimension should be broadcastable or not. If the length of x along these dimensions is not 1, a ValueError will be raised. Returns ------- tensor A theano tensor, which is unbroadcastable along the specified dimensions. (RRRMRRRR(R7RTRRn((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytpatternbroadcasts5RcB`seZdZeZdZddZdZdZdZ dZ dZ d Z d Z d Zd Zd ZRS(s Concatenate multiple `TensorVariable`s along some axis. The axis must be given as first argument. All tensors must have the same shape along all dimensions other than this axis. Of course, TensorVariable instances do not have a shape, so this error cannot be caught until runtime. See `perform()`. See Also -------- stack : For joins involving scalar values Examples -------- >>> x, y, z = tensor.matrix(), tensor.matrix(), tensor.matrix() >>> u = tensor.vector() >>> r = join(0, x, y, z) >>> c = join(1, x, y, z) >>> join(2, x, y, z) # WRONG: the axis has to be an index into the shape >>> join(0, x, u) # WRONG: joined tensors must have the same rank tviewicC`s3||_|dkr/id|gd6|_ndS(Niii(RR8(RR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(s  c`sMjdkrjjSdjjdjfdjDfSdS(Nis%s{%s}s, c3`s(|]}d|t|fVqdS(s%s=%rN(R?(R,tp(R(s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pys s(RRR'R$R(R((Rs3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR%s   cC`s/|jj|t|ds+d|_ndS(NRi(t__dict__tupdateRIR(RRl((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt __setstate__sc`s|d|d}}|s*tdng|D]}t|^q1}g|D]}|jj^qP}tj|fd}|j||||S(s Parameters ---------- axis: an Int or integer-valued Variable tensors A variable number (but not zero) of tensors to concatenate along the specified axis. These tensors must have the same shape along all dimensions other than this axis. Returns ------- A symbolic Variable It has the same ndim as the input tensors, and the most inclusive dtype. iis$Cannot join an empty list of tensorsc`stdd|S(NR1RT(R(Rm(t out_dtype(s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt output_makers(ROReRPR1RQRBt_make_node_internal(Rtaxis_and_tensorsR'ttensorsR7tas_tensor_variable_argstdtypesR((Rs3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRsc C`s[td|Ds%tdnt|dkrPt|djj}nZtgt|djj}t|}t|tsyt t |}Wqt k rqXnt|tr|| krt d||fn|dkr||7}nxV|D]N}xEt |jjD]1\}} ||krAq#n| r#t||ssRJoin cannot handle arguments of dimension 0. For joining scalar values, see @stackiis"Join axis %d out of bounds [0, %d)s=Join argument "axis" is out of range (given input dimensions)s@Join() can only join tensors with the same number of dimensions.s)Axis could not be cast to an integer type(R5R\RMRVRPRTR|R/RRRRRR-RgRORHReRdR ( RR'RRRRmRHR7t current_axistbflagRRNR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRsR            ,c C`s|\}|j}|d|d}}|dkrtjg|d|!||dD]}|j|dk^qSr|||d>> tensor = theano.tensor.tensor3() >>> theano.tensor.shape_padaxis(tensor, axis=0) DimShuffle{x,0,1,2}.0 >>> theano.tensor.shape_padaxis(tensor, axis=1) DimShuffle{0,x,1,2}.0 >>> theano.tensor.shape_padaxis(tensor, axis=3) DimShuffle{0,1,2,x}.0 >>> theano.tensor.shape_padaxis(tensor, axis=-1) DimShuffle{0,1,2,x}.0 See Also -------- shape_padleft shape_padright Dimshuffle is%axis {0} is out of bounds [-{1}, {1})iR7( ReRHtformatRRRPtinsertR#RT(RR'RRHRRRK((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyt shape_padaxisas    %c O`s| r| rtdn| r]t|dttf r]tjdtddd}nd|kr|d}d|kr|d}qd}nHt|dkr|d }nd|kr|d}nd}|d}t|dkrtd ntj g|D]T}t|tj t t t fp\t|to\t|jto\|jdk^q rttt|}tjg|D]}|j^q}tjjj||St|g|D]}t||^qS( sStack tensors in sequence on given axis (default is 0). Take a sequence of tensors and stack them on given axis to make a single tensor. The size in dimension `axis` of the result will be equal to the number of tensors passed. Note: The interface stack(*tensors) is deprecated, you should use stack(tensors, axis=0) insted. Parameters ---------- tensors : list or tuple of tensors A list of tensors to be stacked. axis : int The index of the new axis. Default value is 0. Examples -------- >>> a = theano.tensor.scalar() >>> b = theano.tensor.scalar() >>> c = theano.tensor.scalar() >>> x = theano.tensor.stack([a, b, c]) >>> x.ndim # x is a vector of length 3. 1 >>> a = theano.tensor.tensor4() >>> b = theano.tensor.tensor4() >>> c = theano.tensor.tensor4() >>> x = theano.tensor.stack([a, b, c]) >>> x.ndim # x is a 5d tensor. 5 >>> rval = x.eval(dict((t, np.zeros((2, 2, 2, 2))) for t in [a, b, c])) >>> rval.shape # 3 tensors are stacked on axis 0 (3, 2, 2, 2, 2) >>> x = theano.tensor.stack([a, b, c], axis=3) >>> x.ndim 5 >>> rval = x.eval(dict((t, np.zeros((2, 2, 2, 2))) for t in [a, b, c])) >>> rval.shape # 3 tensors are stacked on axis 3 (2, 2, 2, 3, 2) >>> x = theano.tensor.stack([a, b, c], axis=-2) >>> x.ndim 5 >>> rval = x.eval(dict((t, np.zeros((2, 2, 2, 2))) for t in [a, b, c])) >>> rval.shape # 3 tensors are stacked on axis -2 (2, 2, 2, 3, 2) sCtheano.tensor.stack(tensors, axis) must have at least one parameterisLstack(*tensors) interface is deprecated, use stack(tensors, axis=0) instead.t stackleveliRR'iis_tensors is empty. You should at least provide one tensor to theano.tensor.stack(tensors, axis).(R`R/RVRYRRtDeprecationWarningRMR*R+tnumberRRtpython_complexR RPRRHtmapReRQRBR1RRRRR$R(RRR'RRR1((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR[s61!            a%cC`s4t|ttfs'td|nt||S(sAlias for `join`(axis, *tensor_list). This function is similar to `join`, but uses the signature of numpy's concatenate function. Raises ------ TypeError The tensor_list must be a tuple or list. sThe 'tensors' argument must be either a tuple or a list, make sure you did not forget () or [] around arguments of concatenate.(R/RYRVR\R$(t tensor_listR'((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR1s  cC`st|}|jdkr.td|n|jjdrBdSt|tjrs|jjdkrst|j S|j rt|j j t j jjrt|j jS|j rt|j j tr|j jdjjS|j rUt|j j t j jjrUt|j j jdtrU|j jdj rUt|j jdj j t jjjrUtt j jj|j j|j j jdj}tt j jj|j j|j j jdj}tt j jj|j j|j j jdj}|j jdj jdj}tjtj f}|dkr:d}n=t||rw|dkrw||7}|dkrwd}qwn|dkr|}n@t||r||kr|}q|dkr||7}qn|dkrd}nt||rUt||rUt||rU|dkrU|dkrU|dkrU||krU||d|dSnt|t"rt j#j$|dd}n t%|}t&d|dS(sReturn the run-time length of a symbolic vector. Parameters ---------- v A rank-1 TensorType variable. Raises ------ TypeError `v` hasn't the proper type. ValueError No special case applies, the length is not known. In general this is not possible, but for a number of special cases the length can be determined at compile / graph-construction time. This function implements these special cases. is*argument must be symbolic vector, got '%s'itfileR_slength not known: %sN('ReRHR\RPRTR/RR RMRsRRJRRRRRRRRRRhRRRUt get_idx_listtstarttstoptsteptnumberstIntegralR*RRLR Rt debugprintR_RO(RRRRRHttypesR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRsd  $ ' (%%%             cG`sQt|dkstx&|D]}|jjdkstqWt|ddS(s Horizontally stack two L{TensorType}s. Stack two L{TensorType}s along the second axis (column wise). These L{TensorType}s must have the same shape along all dimensions but the second. iR'i(RMRhRPRHR1(Rtarg((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pythorizontal_stackPs cG`sQt|dkstx&|D]}|jjdkstqWt|ddS(NiR'i(RMRhRPRHR1(RR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytvertical_stackfs tReshapecB`seZdZidgd6ZeZeZd ZddZ dZ dZ dZ dZdZd Zd Zd Zd ZRS(sPerform a reshape operation of the input x to the new shape shp. The number of dimensions to which to reshape to (ndim) must be known at graph build time. iRHcC`s%||_|dks!tddS(Ns.name attribute for Reshape has been deprecated(RHRLRh(RRHRG((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(|s cC`sd|jj|jfS(Ns%s{%s}(RR'RH(R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR%sc C`st|}|}t|dd}|jtkpQt|toQ|jjdksltd||jn|jdkst t|trg|jD]}|dk^q}t j |||gt |j j|gStg|j}|}t|dr|jdkr|g}nxjt|jD]Y}||} t| } y)t| doj| jdk||s(i(i( RHRORYRR3RTR5RRRtfilterRW(R7Rtdimst x_reshapedRR((RTs3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs'   $tTilecB`sJeZdZdZdZdZdZdZdZdZ RS( s Construct an array by repeating the input x according to reps pattern. .. note:: Deprecated Use tile() instead. Tiles its input according to reps. The length of reps is the number of dimension of x and contains the number of times to tile x in each dimension. See Also -------- numpy.tile : http://docs.scipy.org/doc/numpy/reference/generated/numpy.tile.html RHcC`s ||_dS(N(RH(RRH((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(0scC`s|jjd|jS(Ns {ndim=%d}(RR'RH(R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR%3scC`s`tjdddt|}t|}tj|||gt|jjtg|j gS(Ns1Tile op is deprecated, use tile function instead.Ri( RRReRR RRPR1R|RH(RR7treps((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR6s    $cC`s|\}}|\}tj||}|j|jkrHtdntj|dkjrtj||r|j}qn||ds   c C`s[|j\}}|d}||}g}x(t|jD]}|j||q9W|gS(Ni(RRRHR;( RRRR7RRt tiled_shpRR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRNs   cC`s"|\}}|\}tdS(N(R (RRR R7RR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR bs  (sndim( R'R(R)RR(R%RRRR (((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs     cC`s|d k r*||jkr*tdnt|ttfs:t|}|j}|jtj j krxtdn|dkr|g}q|dkr+|d krtdq7||j d}tj j j |t|d}gt|D]&}t||kd|||^q}|}qtdn|d k rgt||krgtdntjg|D]9}t|tpt|to|jtj j k^qtstdnt|}|d krtjt||j}nt||kr+dg|t||}ndg||jgt|jD]}|j |^qL} || } t|| } tj|d jd |} | jj} | j| } gt| D]\}} | ||^q}| j|} | S( sX Tile input array `x` according to `reps`. See the docstring of `numpy.tile` for details. 'reps' can be constant integer (e.g. 3), constant vector(e.g. [2 3]), symbolic scalar (e.g. tensor.iscalar()), symbolic vector (e.g. tensor.ivector()) or a list of symbolic scalar (e.g. [tensor.iscalar(), tensor.iscalar()]). ndim is the number of the dimensions of the output, if it is provided, ndim should be equal or larger than x.ndim and len(reps), otherwise, we will use max(x.ndim, len(reps)) as ndim. If reps is symbolic vector, the ndim has to be provided. s*ndim should be equal or larger than x.ndims&elements of reps must be integer dtypeiis5if reps is tensor.vector, you should specify the ndims)the dimension of reps should not exceed 1s+len(reps) should be equal or less than ndims1elements of reps must be scalars of integer dtypeiN( RLRHROR/RVRYReR1RRRRRtassert_RkRWReRMR*R+RRRRRRnR@R3R0RRUR-(R7RRHt reps_astensort ndim_checktoffsetRtreps_trRt alloc_shapeR8t shuffle_indRt new_shapes((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRisH      !9  F  ; -tARangecB`sheZdZd ZdZdZejjdddZ dZ dZ d Z d Z RS( sCreate an array containing evenly spaced values within a given interval. Parameters and behaviour are the same as numpy.arange(). R1cC`s ||_dS(N(R1(RR1((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(scC`stt|||f\}}}|jdks6t|jdksKt|jdks`t|||g}t|jtfg}t|||S(Ni(RReRHRhRR1R|R (RRRRRRN((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs!t warn_float64tignorecC`s|j\}}}d}d}||dr||drUt|dfgS||}||}tt||ddfgSnK||}||}tttt||d|ddfgSdS(NcS`s;y#t|}tj||kSWntk r6nXtS(N(RR*R+RR|(RRR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytis_constant_values   cS`s;|jtkr7tj|jddkr7t|dS|S(NR(R1RSRQRBR%(R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRBs iiRR(RR%RaR(RRti_shapesRRRRRB((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs    #   cC`sb|\}}}|\}|j}|j}|j}tj|||d|j|d/s(snumpys numpy+floatX(RLRReRQRBRPR1RuRvRt cast_policyR*R@RRR5RhR_t_arangeR(RRRR1t numpy_dtypeR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR@s6 ! '       ,  t_nd_gridcB`s#eZdZedZdZRS(sCreate a dense n-dimensional 'meshgrid' with equally spaced points. Used to create the instance ``mgrid`` and ``ogrid`` which act similarly to their numpy equivalents. Parameters ---------- sparse : boolean, optional, default=True Specifying False leads to the equivalent of numpy's mgrid functionality. Specifying True leads to the equivalent of ogrid. Examples -------- >>> a = T.mgrid[0:5, 0:3] >>> a[0].eval() array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4]], dtype=int8) >>> a[1].eval() array([[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]], dtype=int8) >>> b = T.ogrid[0:5, 0:3] >>> b[0].eval() array([[0], [1], [2], [3], [4]], dtype=int8) >>> b[1].eval() array([[0, 1, 2, 3]], dtype=int8) cC`s ||_dS(N(tsparse(RR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(esc G`st|d}x3|dD]'}t|jtrtdqqWg|dD]-}t|jpfd|j|jpxd^qQ}gt|D]@\}}t dg||j dgdg|d|^q}gt ||D]\}}|j |^q}|j r|} ng} g|D]}t|^q'} xit|D][} d} x?t|D]1}|| kr| ||} qe| | |} qeW| j| qLW| S(Nis0Not implemented for slices whose step is complexi(RMR/RRR R@RRR-RYRRR3RRRWR;( RRRHtsltrangesR[RR?RtgridsRRtgrid((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRhs*;P1   (R'R(R)R|R(R(((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR>s% RtPermuteRowElementscB`sAeZdZdZdZdZdZdZdZRS(sPermute the elements of each row (inner-most dim) of a tensor. A permutation will be applied to every row (vector) of the input tensor x. Depending on the dimensionality of x and the permutation tensor y, different cases are possible. If y.ndim = 1, y is a single permutation, that will be applied to every vector of x. For instance, if x is a matrix, the same permutation will be applied to each row of x. If x.ndim = y.ndim, each row of x corresponds to a row of y, containing a permutation that will be applied to that row. For instance, if x and y are two matrices, a different permutation will be applied to each row of x. If x.ndim > y.ndim, y will be broadcasted to fit x, then each row (vector) of x will be reordered according to the corresponding row of y. (This is a generalization of the first case). If x.ndim = 1, every permutation in y will be applied to x, and the output will contain all the results. If x.ndim < y.ndim, x will be broadcasted to fit y, and different permutations contained in y will be applied to each vector in x. (This is a generalization of the previous case). If the "inverse" argument is True, the Op will perform the inverse permutation instead. c C`sZt|}t|}|r-td}n td}|jjtksQt|jjdkru|jjtks{t|jj}|jj}||krt|d||}n%||krt|d||}ngt|jj|jjD]\}}|o|^q}t d|jjd|} |||g} | g} t || | S(NiiRER1RT( ReRPR1RSRhRHRXRRTRR ( RR7R8tinversetx_dimty_dimtxbtybtout_broadcastabletout_typet inputlistt outputlist((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs&   *    7 c C`st|jdkr7|r)|||t d|j||D]"}|dc|j |d 9axes to sum over must not contain the batch axis (axes[%i]=%s)RYRZN(ReR*tisscalarRMROR_RRHRhR1RRTRRR3RRR-RRRUR[(R-R.R6RYRZt operand_nametoperandt batch_axest a_outaxest b_outaxestoutshapetoutbcasttoutndimta_shapetb_shapeRt a_reshapedt b_reshapedt out_reshapedRtaxes_R7t other_axest a_shuffledt b_shuffled((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR[Vs" %     !!   "2&`cC`st|||dtdtS(s Compute a generalized dot product over provided axes. Given two tensors a and b, tensordot computes a generalized dot product over the provided axes. Theano's implementation reduces all expressions to matrix or vector dot products and is based on code from Tijmen Tieleman's gnumpy (http://www.cs.toronto.edu/~tijmen/gnumpy.html). Parameters ---------- a: symbolic tensor The first tensor variable. b: symbolic tensor The second tensor variable axes: int or array-like of length 2 If an integer, the number of axes to sum over. If an array, it must have two array elements containing the axes to sum over in each tensor. Note that the default value of 2 is not guaranteed to work for all values of a and b, and an error will be raised if that is the case. The reason for keeping the default is to maintain the same signature as numpy's tensordot function (and np.tensordot raises analogous errors for non-compatible inputs). If an integer i, it is converted to an array containing the last i dimensions of the first tensor and the first i dimensions of the second tensor: axes = [list(range(a.ndim - i, b.ndim)), list(range(i))] If an array, its two elements must contain compatible axes of the two tensors. For example, [[1, 2], [2, 0]] means sum over the 2nd and 3rd axes of a and the 3rd and 1st axes of b. (Remember axes are zero-indexed!) The 2nd axis of a and the 3rd axis of b must have the same shape; the same is true for the 3rd axis of a and the 1st axis of b. Returns ------- symbolic tensor A tensor with shape equal to the concatenation of a's shape (less any dimensions that were summed over) and b's shape (less any dimensions that were summed over). Examples -------- It may be helpful to consider an example to see what tensordot does. Theano's implementation is identical to NumPy's. Here a has shape (2, 3, 4) and b has shape (5, 6, 4, 3). The axes to sum over are [[1, 2], [3, 2]] -- note that a.shape[1] == b.shape[3] and a.shape[2] == b.shape[2]; these axes are compatible. The resulting tensor will have shape (2, 5, 6) -- the dimensions that are not being summed: >>> a = np.random.random((2,3,4)) >>> b = np.random.random((5,6,4,3)) #tensordot >>> c = np.tensordot(a, b, [[1,2],[3,2]]) #loop replicating tensordot >>> a0, a1, a2 = a.shape >>> b0, b1, _, _ = b.shape >>> cloop = np.zeros((a0,b0,b1)) #loop over non-summed indices -- these exist #in the tensor product. >>> for i in range(a0): ... for j in range(b0): ... for k in range(b1): ... #loop over summed indices -- these don't exist ... #in the tensor product. ... for l in range(a1): ... for m in range(a2): ... cloop[i,j,k] += a[i,l,m] * b[j,k,m,l] >>> np.allclose(c, cloop) true This specific implementation avoids a loop by transposing a and b such that the summed axes of a are last and the summed axes of b are first. The resulting arrays are reshaped to 2 dimensions (or left as vectors, if appropriate) and a matrix or vector dot product is taken. The result is reshaped back to the required output dimensions. In an extreme case, no axes may be specified. The resulting tensor will have shape equal to the concatenation of the shapes of a and b: >>> c = np.tensordot(a, b, 0) >>> print(a.shape) (2,3,4) >>> print(b.shape) (5,6,4,3) >>> print(c.shape) (2,3,4,5,6,4,3) See the documentation of numpy.tensordot for more examples. RYRZ(R[RYR|(R-R.R6((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR5sdcC`sa|jdkr|j}n|jdkr<|j}nt|jdd|jddS(s_Return vector-vector outer product. If an input isn't a vector, we flatten it first. iiR7(RHRRYRU(R7R8((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR8scC`s4tj||}|r0t|||}n|S(N(RtAnyR](R7R'R^R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytanyGscC`s4tj||}|r0t|||}n|S(N(RtAllR](R7R'R^R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR+Ost ExtractDiagcB`sMeZdZd ZdddedZdZd Zd Zd Z RS( sReturn specified diagonals. Parameters ---------- x A tensor variable with x.ndim >= 2. Returns ------- vector A vector representing the diagonal elements. Rtaxis1taxis2RiicC`sz||_|jr<t r<tjdtjjt|_n|jr[idgd6|_n||_||_ ||_ dS(NsView will forced to False. ExtractDiag property view is set to True but numpy version %s and prior versions of numpy.diagonal() do not return a view. Update numpy to use ExtractDiag(view=True)i( Rtnumpy_diagonal_return_viewRRR*tversionR|R8RRMRN(RRRMRNR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(ms      c C`slt|}|jdkr-td|nt||g|jjd|jdtg|jdgS(Nis4ExtractDiag needs an input with 2 or more dimensionsR1RTi(ReRHROR RPRR1R|(RR7((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR|s   cC`sX|\}|\}|j|j|j|j|d<|jsT|dj|d|||fdkr(tjjj|St||||S(Nii(iii(RRtnlinalgt extract_diagRL(R-RRMRN((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRQstDiagcB`s2eZdZdZdZdZdZRS(cC`sUt|}|jjdkr3td|jnt||gtd|jgS(Nisdata argument must be a vectorR1(ReRPRHR\R RR1(Rtdiag((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyRs cC`s$|\}tj|d|d>> from theano.tensor import stacklists, scalars, matrices >>> from theano import function >>> a, b, c, d = scalars('abcd') >>> X = stacklists([[a, b], [c, d]]) >>> f = function([a, b, c, d], X) >>> f(1, 2, 3, 4) array([[ 1., 2.], [ 3., 4.]], dtype=float32) We can also stack arbitrarily shaped tensors. Here we stack matrices into a 2 by 2 grid: >>> from numpy import ones >>> a, b, c, d = matrices('abcd') >>> X = stacklists([[a, b], [c, d]]) >>> f = function([a, b, c, d], X) >>> x = ones((4, 4), 'float32') >>> f(x, x, x, x).shape (2, 2, 4, 4) N(R/RYRVR[Rt stacklists(R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR\scC`s,t|}t||t||}|S(s^ Range of values (maximum - minimum) along an axis. The name of the function comes from the acronym for peak to peak. Parameters ---------- a Input tensor. axis Axis along which to find the peaks. By default, flatten the array. Returns ------- array A new array holding the result. (ReRRc(R-R'R((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytptps cC`s||S(N((R7R8((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytpower scC`sTt|}|j}ttd|}||||||<||<|j|S(sswap axes of inputted tensori(ReRHRVRWRU(R8RMRNRHtli((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytswapaxes s   traisecC`s%|dkstt|||S(s Construct an array from an index array and a set of arrays to choose from. First of all, if confused or uncertain, definitely look at the Examples - in its full generality, this function is less simple than it might seem from the following code description (below ndi = numpy.lib.index_tricks): np.choose(a,c) == np.array([c[a[I]][I] for I in ndi.ndindex(a.shape)]). But this omits some subtleties. Here is a fully general summary: Given an ``index`` array (a) of integers and a sequence of n arrays (choices), a and each choice array are first broadcast, as necessary, to arrays of a common shape; calling these Ba and Bchoices[i], i = 0,...,n-1 we have that, necessarily, Ba.shape == Bchoices[i].shape for each i. Then, a new array with shape Ba.shape is created as follows: - if mode=raise (the default), then, first of all, each element of a (and thus Ba) must be in the range [0, n-1]; now, suppose that i (in that range) is the value at the (j0, j1, ..., jm) position in Ba - then the value at the same position in the new array is the value in Bchoices[i] at that same position; - if mode=wrap, values in a (and thus Ba) may be any (signed) integer; modular arithmetic is used to map integers outside the range [0, n-1] back into that range; and then the new array is constructed as above; - if mode=clip, values in a (and thus Ba) may be any (signed) integer; negative integers are mapped to 0; values greater than n-1 are mapped to n-1; and then the new array is constructed as above. Parameters ---------- a : int array This array must contain integers in [0, n-1], where n is the number of choices, unless mode=wrap or mode=clip, in which cases any integers are permissible. choices : sequence of arrays Choice arrays. a and all of the choices must be broadcastable to the same shape. If choices is itself an array (not recommended), then its outermost dimension (i.e., the one corresponding to choices.shape[0]) is taken as defining the ``sequence``. out : array, optional If provided, the result will be inserted into this array. It should be of the appropriate shape and dtype. mode : {``raise`` (default), ``wrap``, ``clip``}, optional Specifies how indices outside [0, n-1] will be treated: ``raise`` : an exception is raised ``wrap`` : value becomes value mod n ``clip`` : values < 0 are mapped to 0, values > n-1 are mapped to n-1 Returns ------- merged_array - array The merged result. Raises ------ ValueError - shape mismatch If a and each choice array are not all broadcastable to the same shape. N(RLRhtChoose(R-tchoicesRR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pytchoosesARbcB`s2eZdZdZdZdZdZRS(RcC`s|dkst||_dS(NRatwrapRJ(sraiseswrapsclip(RhR(RR((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyR(^sc C`st|jdtrg}x\t|d|dd|jdjD]2\}}}|rj|j|qE|j|qEWt|gSddl}t|jd|jj st t d|d}x4t t |ddD]} |d| || RHRIRJtOperatorPrinterRUR0RXRVR`R\RRRRRR$RRXRRR[R1RRRRR3RRRRRRRR@tobjectRtmgridtogridRRRRRR6tspecialRYR[R5RR7RRQRORLRYRZR\R]R^R`RdRbRq(((s3/tmp/pip-build-X4mzal/theano/theano/tensor/basic.pyts     "" "    \'            $  $  $  ''$$$     - # )     %9*  "n   5  ,  &!  "       + ]L(      ' '    9   5%f K   =K NT0G       3 { g  G #   ET