Xc @`sddlmZmZmZddlmZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlmZmZddlmZmZddlZddlmZddlmZddlmZmZmZmZdd lmZmZdd lm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'ddl(m)Z)m*Z*ddl+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6ddlm7Z7ddl8m9Z9ddl:m9Z;ddlm<Z<ddl=m>Z>m?Z?ddl@mAZAmBZBmCZCddlmDZDmEZEmFZFddlmGZGddlHmIZImJZJmKZKmLZLmMZMmNZNddlmOZOejPdZQdZRdZSdZTeUeVdZWeXdZYdeDfd YZZeZe;j)Z[e<j\j]d!e[d"d#d$d%d&d'Z^d(Z_d)Z`d*Zad+Zbd,Zce_e`ejde;jegd-Zfd.Zgd/Zhejde*gd0Zie_ejdeNgd1Zje_ejde*gd2Zke_eieaeie_eaejde;jlgd3Zme_eaejde;jngd4Zod5e;jpfd6YZqeqZrd7fd8YZse;jtjueqesd9evfd:YZwd;eDfd<YZxd=eDfd>YZyej<jzj\j]d?exd@d%dAej<jzj\j]dBeydCdDZ{eaejde;j)ge{e;j)e;jIe;j*dEZ|ejde;j)gdFZ}e_e}eae`ejde;j~gdGZe<j\j]dHe!edId%e<j\j]dJe!e|dKd%e_dAe^ejde;j~gdLZeae`e_e^ejde;jgdMZeae`e_ejde;jgdNZejde;jgdOZe<j\j]dPe!edQdReae_ejde;j>gdSZeae_ejdeXdTZeae_ejde.gdUZeae_ejde.gdVZeae_dWe^ejde.e3gdXZe^e_dAeaejde;j)gdYZeaejde;j)gdZZe_eaejde;j)gd[Ze_eaejde;j)gd\Zd]Zd^e;jpfd_YZeZeZeaejdegd`ZejdegdaZe<j\dbj]dcedddeeVe<j\dfj]dcedddeeVe<j\dgj]dcedddeeVe<j\dhj]dcedddeeVe_ejde;j)gdiZe^e_eaejde/gdjZe_ejde1gdkZe^e_eaejde.gdlZe_eaejde.e3gdmZe_dAejde.gdnZdoZe_eaejde.gdpZe^e_eaejde.gdqZe_e`eaejde.gdrZe_ejde;jgdsZe<j\j]dte!edud%ejde/gd&eUdvZe<j\j]dweedxejdyd%d&ejde1gd&eUdzZe<j\j]d{eedxejdyd%d&e_d|e`d|ejde/e2e1gd}Ze_d~e`d~ejde/gdZe_e`ejde3gdZeae`e_e^ejde/e2e1gdZe^e_eaejde;jgdZe_eaejde;jgdZdZeae_e^ejde;jgdZe^eae_ejde;jgdZeae_e^ejde;jgdZe_eaejde;jjgdZe`eae_ejde;j)gdZe^de_dAdeaejde;j)gdZeae_ejde;jgdZe_ejde;je;jgdZe_ejde;j)gdZe^e_e`ejde;jgdZe^e_eaejde;jgdZe_e`ejde;jgdZdZe_ee;jNdde^e_e`ejde;jNgdZe_ejde;jNgdZe_e`ejde;jNgdZe_eje;jdddejfdYZeVeXdZee;je;je;jeeVZe_eddejde;jgdZe_eeaejde;je;jjgdZeaejde;j)gdZe^eae`e_ejde;j)gdZe_eaejde;je;jjgdZe_ejde;je;jjgdZe_ejde;je;jjgdZe;jje;jje;jje;jje;jje;jjgZe_ebejdedZe_dAde^dejdedZe_ebeaejdedZeaejde;je;jjgdZeaejde;jgdZeaejde;jgdZejde;jgdZe_eejde;jgdZeaeejde;jgdZe_eejde;jgdZe_eeaejde;jgdZe_ejde;jgdZe_eaejde;je;jgdZejde;jgdZeaeecejde;jgdZejde;jgdZeaeejde;jgdZeaee!ejee}deUddZdZejede_ejde;jgdZeaejde;je;jgdZe`eaejde;jgdZe`eaejde;jgdZejde;jgdZe<j\j]de!edeUdd%eVeXdZee;je;je;jeZe!ejee}deUddZe_eddddZdZe_e`ejde;je;je;jgdZejdeXdZe!edeUddZe_edAdeUebedAdeUe`edAdeUeaedAdeUdZdZeje;jde;jdffe;je;jdffdeUddde;jgdeZe_ee`eeaeeje;jde;jdffe;jdfdeUddZe_ee`eeaeeje;jde;jde;jdfffe;jdfdeUddZe_ee`eeaeeje;jde;je;jdfffe;jdfdeUddde;jgdeZe_ee`eeaeeje;jde;jdffe;je;jdffdeUddde;jgdeZ e_e e`e eae eje;jde;jdffe;jdfdeUddde;jgdeZ e_e e`e eae eje;jde;je;jdfffe;jdfdeUddde;jgdeZ e_e e`e eae eje;jde;jde;jdfffe;jdfdeUddde;jgdeZ e_e e`e eae eje;jde;je;jdfffe;jdfdeUddde;jgdeZ e_e e`e eae eje;jde;je;jdfffe;jdfdeUddde;jgdeZe_ee`eeaeeje;jde;je;jddfffe;jdfdeUddde;jgdeZe_ee`eeaee`eaejde;jgdZe`eaejde;jgdZdeXdZdZee;j)eZdeDfdYZdZe'jjreQjdejZej]deedd%dej]deedd%de<j\j]dedd%dddn2eQjde<j\j]deedddde_ejde)gdZe_ejejjdAd%dde_ejejjdAd%dde_ejejjdAd%dde_ejdejj gdZ!e^e_e`eaejde;jIgdZ"dS(i(tabsolute_importtprint_functiontdivision(t defaultdictN(t integer_typest iteritems(treducetxrange(tgof(tizip(topttInconsistencyErrort TopoOptimizertgraph(tVariabletConstant(tcopy_stack_tracetin2out(tMethodNotDefined(tDisconnectedType(tconfig(tElemwiset DimShuffle( t get_idx_listtget_canonical_form_slicet Subtensort IncSubtensort make_constanttAdvancedIncSubtensor1tAdvancedIncSubtensortAdvancedSubtensor1tadvanced_subtensortadvanced_subtensor1tadvanced_inc_subtensor1(tscalar(tbasic(tcompile(tShapetShape_i(tvalues_eq_approx_remove_inftvalues_eq_approx_remove_nantvalues_eq_approx_remove_inf_nan(t Optimizertpre_constant_mergetpre_greedy_local_optimizer(ttoolbox(tAlloctget_scalar_constant_valuet ShapeErrortextract_constanttNotScalarConstantErrortReshape(tStringIOstheano.tensor.optcC`s*x |D]}tj||}qW|gS(N(tTtfill(tnew_outt orig_inputsti((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt _fill_chain=s cC`sKt|t|krtS|t| }tdt||D S(sB Parameters ---------- b1 The broadcastable attribute of a tensor type. b2 The broadcastable attribute of a tensor type. Returns ------- bool True if the broadcastable patterns b1 and b2 are such that b2 is broadcasted to b1's shape and not the opposite. cs`s"|]\}}|o| VqdS(N((t.0tv1tv2((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys Ws(tlentFalsetanytzip(tb1tb2((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytencompasses_broadcastableCscC`s#gt|D]}t|^q S(N(RAtall(tbroadcastablestbcast((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytmerge_broadcastablesZscC`sg}g}g}xe|D]]}y6t|d|d|}|j||j|Wqtk ru|j|qXqW|||fS(sQPartition a list of variables into two kinds: scalar constants, and the rest.telemwisetonly_process_constants(R/tappendR2(tinputsRIRJtconstst origconstst nonconstsR9tv((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytscalarconsts_rest^s    cC`stj|}|j|jkr%|S||jkrCtdn|dkr[|j}ntj||}|j|jkr|St|dr|j j |}n |j }tj ||}|j |j krtj|gt|jD]'}|j |r|j | r|^q}n|jj|ks6t|jj |j kr{tdt|jj dt|j n|S(s Return a Variable with the same shape and dtype as the template, filled by broadcasting value through it. `value` will be cast as necessary. sSbroadcast_like currently requires the template Variable to be in the fgraph alreadyt shape_featuresrval.type.broadcastable is s but template.broadcastable isN(R5tas_tensor_variablettypet variablestNotImplementedErrortNonetdtypetcastthasattrRRtshape_oftshapetalloct broadcastablet unbroadcastRtndimtAssertionErrortstr(tvaluettemplatetfgraphRXt new_shapetrvalR9((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytbroadcast_likeos0     tInplaceElemwiseOptimizercB`sPeZdZdZdZeddZdZej dddZ RS(sL We parametrise it to make it work for Elemwise and GpuElemwise op. cC`s ||_dS(N(top(tselftOP((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt__init__scC`s|jtjjjdS(N(tattach_featurettheanoRtdestroyhandlertDestroyHandler(RkRe((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytadd_requirementssicC`sd|}t|d|djd|x4ddddgD] }t||||d|q:W|d }|rt|d d d|x7t|jD] }t||||d|qWndS( Ns sInplaceElemwiseOptimizer R tfilet node_beforetnb_call_replacetnb_call_validatetnb_inconsistentR`tnb(tprintRjtsortedtkeys(tstreamtproftleveltblanctkR`tn((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt print_profiles   c& C`s%i|d6t|jd6dd6dd6dd6tdd6}tjj}|d krt|jd krxd }qd }nd}|j}|jrg|jD]}|j|^q}ng}g|j D]'}t |t j j jr|j^q} t| g} | j|jxttj|j|jD]} | j} t| |jksgq=n|d krt| jdjdd dkrq=n| jr_| j} gtt| jD]}|| kr|^q} gtt| jD]_}|| jkrt | j|t r|j| j| r| j|| kr|^q}ng} ttt| j} gtt| jD]M}t | j|t r|j| j| r| j|| kr|^q}t}| }x| D]}| j|}|}||krSg}x\t |jD]K\}}||kr8||jkr8|j|}|j!|j|q8q8Wg}g}g}x|D]}| j|}||kr|j!|qt"|d r1|j#r1t$g|D]'}|j%j&j'|d|j#k^qr1|j!|q|j!|qW|||}nxi|D]a}| j|j| j|jkrqZnt)| }||| x += y += z` `(x + y) * (x * y) -> (x += y) *= (x * y) or (x + y) *= (x *= y)` R RtiRuRvRwcS`sdS(Ni((((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytsR`iii itdestroy_handlertmake_new_inplacet return_listtreasontinplace_elemwise_optimizersDSome inplace optimization was not performed due to unexpected error:RssCSome inplace optimization was not performed due to unexpected errorN(=R>t apply_nodesRRttensort$insert_inplace_optimizer_validate_nbt checkpointtupdate_mappingtoutputst _featurest isinstanceRoR$tfunction_modulet Supervisort protectedtsumtextendtlistR t io_toposortRLRjRTtgetattrtinplace_patternRtvaluesRt destroyerstrangeR?t enumerateRKRZtownerR@Rtroot_destroyertgetRWtdictt scalar_opRR"t transfer_typeRXt __class__tTrueRAtreplaceR`tvalidatet ValueErrorR Rytsyststderrtreverttremovet Exception(&RkReR}tcheck_each_changetnb_change_no_validatetchkR9t update_outstftprotected_inputstnodeRjtbaselinetcandidate_outputstcandidate_inputstverbosetraised_warningtcandidate_outputtcandidate_out_vartsorted_candidate_inputstupdated_inputstf_outtupdated_inp_idxt updated_varstvars_from_inplacet other_varstinp_idxtinptup_inptcandidate_inputRtotnew_scalt new_outputstnew_nodetrtnew_rte((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytapplys&       &'%  "  "        4     = 7                 icC`s.tdd||jj|jfd|tS(Ns %s%s (%s)t Rs(RyRt__name__RjR(RkR|R~tdepth((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt print_summarys$( Rt __module__t__doc__RmRrt staticmethodRRRtstdoutR(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRis   tinplace_elemwise_optiKt inplace_optRtfast_runtinplacec`spttkr+fd}|SjddpCj}tjjj|ddSdS(Nc`st|S(N(tregister_useless(t inner_lopt(tkwargstloptttags(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytregisterstnametlastR( RTRbtpopRWRR$tmodet local_uselessR(RRRRR((RRRs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs c`snttkr+fd}|SjddpCj}tjdj|dSdS(Nc`st|S(N(tregister_canonicalize(R(RRR(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRsRt canonicalizeR(RTRbRRWRR$toptdbR(RRRRR((RRRs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs c`snttkr+fd}|SjddpCj}tjdj|dSdS(Nc`st|S(N(tregister_stabilize(R(RRR(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRsRt stabilizeR(RTRbRRWRR$RR(RRRRR((RRRs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs c`snttkr+fd}|SjddpCj}tjdj|dSdS(Nc`st|S(N(tregister_specialize(R(RRR(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRsRt specializeR(RTRbRRWRR$RR(RRRRR((RRRs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs c`stttkr+fd}|SrCjddpIj}tjdj|dSdS(Nc`st|S(N(tregister_uncanonicalize(R(RRR(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRsRtuncanonicalizeR(RTRbRRWRR$RR(RRRRR((RRRs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs!c`stttkr+fd}|SrCjddpIj}tjdj|dSdS(Nc`st|S(N(tregister_specialize_device(R(RRR(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRsRtspecialize_deviceR(RTRbRRWRR$RR(RRRRR((RRRs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs!cC`snt|jtjstS|jd}|jd}t}y%t|dtdkr]t}nWntk rqnXy%t|dtdkrt}nWntk rnX|rjtj dd|j dj j }|j dkr>|j dkr>t|tj|jd|jd}tj||jd|jdgS|j dkr|j dkrt|tj|jd|jd}tj||jdgS|j dkr|j dkrt|tj|jd|jd}tj||jdgS|j dkrN|j dkrNt|tj|jd|jd}|gStjd|j |j ndS(NiiRJRXisOptimization Warning: Optimization theano/opt.py:local_0_dot_x Found that it could apply, but was not implemented for dot product with these input types: (%s, %s)(RRjR5tDotR?RLR/RR2tconstantRRTRXR`tassert_teqR\R]t_loggertwarning(RtxtyRt constant_zero((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt local_0_dot_xsF      "#$### cC`s1|js |Stj|j}|r-|dS|S(Ni(Rtlocal_dimshuffle_liftt transform(tvartnew((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytapply_local_dimshuffle_lifts  cC`st}t||jjkrgt|jjD]\}}|r1|^q1dg}x_t|jjD]B}|||ks||kr|||krt}qit}PqiWnt}|S(NR(RR>RTR`RR^RR?(t new_ordertinputt is_uselessR9tis_broadcastabletall_broadcastable_dims((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytis_dimshuffle_useless-s  c C`s|j}t|tstS|jd}|j}|j}|rt|jtrt|j dkrg}xE|jD]:}|j |j j |j|}|j t|qxWt|jd||j|tdt}|S|rFt|jtrFg|D](} | dkr dp-|jj| ^q}|jd}nt||r\|gS|rt|jtr|j |j j ||}t|}t|jd||gSdS(s "Lifts" DimShuffle through Elemwise operations and merges consecutive DimShuffles. Basically, applies the following transformations on the whole graph: DimShuffle(Elemwise(x, y)) => Elemwise(DimShuffle(x), DimShuffle(y)) DimShuffle(DimShuffle(x)) => DimShuffle(x) DimShuffle{0,1,...}(x) => x (when the dimshuffle do nothing) After this transform, clusters of Elemwise operations are void of DimShuffle operations. iiRRN(RjRRR?RLRRRR>tclientsRRTR^RKRRRRRR( RRjRtinodeRt new_inputsRtnew_inptretR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR@s4    -2 c `sK|j}t|tstS|jdjdk oKt|jdjjtsRtS|jdjjj}|jdjjd}|jdj }gx3t ||D]"\}}|sj |qqWt fdt tdD}|rG|jd}|j|jdj||} t|jd| | gSdS(sO Removes useless DimShuffle operation inside Reshape: reshape(vector.dimshuffle('x', 0), shp) => reshape(vector, shp) reshape(matrix.dimshuffle('x', 0, 'x', 1), shp) => reshape(matrix, shp) reshape(row.dimshuffle(1, 'x'), shp) => reshape(row, shp) reshape(col.dimshuffle(0), shp) => reshape(col, shp) ic3`s'|]}||dkVqdS(iN((R;R9(tnew_order_of_nonbroadcast(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys siN(RjRR3R?RLRRWRRR^RARKRERR>RRR`R( RRjRRRFR9tbdtno_change_in_orderR\R ((R s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt#local_useless_dimshuffle_in_reshapens*   "cC`st|jtjo$|jjdks+tS|jdjoWt|jdjjtjs^tS|jdjj\}}|j |j kodknrtj |j|jg}t |jd||SdS(s dot(x,y).T -> dot(y.T, x.T) These optimizations "lift" (propagate towards the inputs) DimShuffle through dot product. It allows to put the graph in a more standard shape, and to later merge consecutive DimShuffles. The transformation should be apply whether or not the transpose is inplace. The newly-introduced transpositions are not inplace, this will be taken care of in a later optimization phase. iiiN(ii( RRjR5RRR?RLRRR`tdotR(RRRR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt local_lift_transpose_through_dots'"cC`sat|jtjr]|jd}|jr]t|jjtjr]|jjd}|gSndS(s.tensor_from_scalar(scalar_from_tensor(x)) -> xiN(RRjR5tTensorFromScalarRLRtScalarFromTensor(Rtstt((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_tensor_scalar_tensors  !cC`sat|jtjr]|jd}|jr]t|jjtjr]|jjd}|gSndS(s.scalar_from_tensor(tensor_from_scalar(x)) -> xiN(RRjR5RRLRR(RRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_scalar_tensor_scalars  !t MakeVectorcB`s_eZdZd ZddZdZdZdZdZdZ d Z d Z RS( sConcatenate a number of scalars together into a vector. This is a simple version of stack() that introduces far less cruft into the graph. Should work with 0 inputs. The constant_folding optimization will remove it. RXtint64cC`s ||_dS(N(RX(RkRX((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRmsc`stttjtfdD s]tdkr(djjkr(tjj jgD]}|j^qsjkst dtfdDst djt gD]}|j^qfngD]}tj |d^qntfdDsJt tdDsft rdjjn jt}tjd |fd}tj|gS( Nc3`s%|]}|jdjkVqdS(iN(RT(R;ta(RL(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys sisPThe upcast of the inputs to MakeVector should match the dtype given in __init__.c3`s0|]&}jtj|djkVqdS(RXN(RXR5RY(R;R9(RXRk(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys ss=MakeVector.make_node expected inputs upcastable to %s. got %sRXc3`s!|]}j|jkVqdS(N(RX(R;R(Rk(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys scs`s|]}|jdkVqdS(iN(R`(R;R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys sR^(RtmapR5RSRER>RXRoR"tupcastRat TypeErrorRbRYRTR?t TensorTypetApply(RkRLR9t bcastabletotype((RXRLRks1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt make_nodes&(.  2+" cC`sj|\}|ddks2|djt|krXtj|d|jdj|dRot_asarrayRRX(RkRRLtout_tout((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytperforms )&cC`sdS(Ni(i((Rk((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytc_code_cache_version sc C`s|\}t|}tj|jdjj}|jdjjd} t|dkr|j|jdjks|td|d}ndt } x+t |D]\} } | dt 7} qW| S(NiisPyArray_TYPE(%s)s npy_intp dims[1]; dims[0] = %(out_shape)s; if(!%(out)s || PyArray_DIMS(%(out)s)[0] != %(out_shape)s){ Py_XDECREF(%(out)s); %(out)s = (PyArrayObject*)PyArray_EMPTY(1, dims, %(out_num)s, 0); } s{ *((%(out_dtype)s *)PyArray_GETPTR1(%(out)s, %(idx)s)) = *((%(out_dtype)s *) PyArray_DATA(%(i)s)); ( R>tnumpyRXRtnumRTt dtype_specsRLRatlocalsR( RkRRRR$tsubR%t out_shapetout_numt out_dtypeR tidxR9((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytc_codes   cC`st|fgS(N(R>(RkRtishapes((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt infer_shape*scC`s}|jtjjkrAg|D]!}|jjtjj^qSg}x/t|D]!\}}|j |d|qTW|S(Ni( RXRoRtdiscrete_dtypest zeros_liketastypeRtfloatXRRK(RkRLtoutput_gradientstipttgradsR9R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytgrad-s)cC`s#d|krdgS|j|jS(N(RWR!R(RkRLt eval_points((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytR_op8s (sdtype( RRRt __props__RmR!R&R'R1R3R;R=(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs      tMakeVectorPrintercB`seZdZRS(cC`s|jdkrtdnt|jjtrt|dd}z8d|_g|jjD]}|j j |^q^}Wd||_Xddj |StddS(NsCan only print make_vector.t precedenceis[%s]s, ( RRWRRRjRRR@RLtpprintertprocesstjoin(RkRtpstatetold_precedenceRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRBAs , (RRRB(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR?@st ShapeFeaturecB`seZdZdZdZdZdZdZdZe dZ dZ d Z d Z d Zd Zd ZdZdZdddZRS(s!Graph optimizer for removing all calls to shape(). This optimizer replaces all Shapes and Subtensors of Shapes with Shape_i and MakeVector Ops. This optimizer has several goals: 1. to 'lift' Shapes to as close to the inputs as possible. 2. to infer the shape of every node in the graph in terms of the input shapes. 3. remove all fills (T.second, T.fill) from the graph Lifting shapes as close to the inputs as possible is important for canonicalization because it is very bad form to have to compute something just to know how big it will be. Firstly, it is a waste of time to compute such outputs. But it is important to get rid of these outputs as early as possible in the compilation process because the extra computations make it appear as if many internal graph nodes have multiple clients. Many optimizations refuse to work on nodes with multiple clients. Lifting is done by using an `.infer_shape` function if one is present, or else using a conservative default. An Op that supports shape-lifting should define a infer_shape(self, node, input_shapes) function. The argument input_shapes is a tuple of tuples... there is an interior tuple for each input to the node. The tuple has as many elements as dimensions. The element in position i of tuple j represents the i'th shape component of the j'th input. The function should return a tuple of tuples. One output tuple for each node.output. Again, the i'th element of the j'th output tuple represents the output[j].shape[i] of the function. If an output is not a TensorType, then None should be returned instead of a tuple for that output. For example the infer_shape for a matrix-matrix product would accept input_shapes=((x0,x1), (y0,y1)) and return ((x0, y1),). Inferring the shape of internal nodes in the graph is important for doing size-driven optimizations. If we know how big various intermediate results will be, we can estimate the cost of many Ops accurately, and generate c-code that is specific [e.g. unrolled] to particular sizes. In cases where you cannot figure out the shape, raise a ShapeError. Notes ----- Right now there is only the ConvOp that could really take advantage of this shape inference, but it is worth it even just for the ConvOp. All that's necessary to do shape inference is 1) to mark shared inputs as having a particular shape, either via a .tag or some similar hacking; and 2) to add an optional In() argument to promise that inputs will have a certain shape (or even to have certain shapes in certain dimensions). We can't automatically infer the shape of shared variables as they can change of shape during the execution by default. (NOT IMPLEMENTED YET, BUT IS IN TRAC) **Using Shape information in Optimizations** To use this shape information in OPTIMIZATIONS, use the ``shape_of`` dictionary. For example: .. code-block:: python try: shape_of = node.fgraph.shape_feature.shape_of except AttributeError: # This can happen when the mode doesn't include the ShapeFeature. return shape_of_output_zero = shape_of[node.output[0]] The ``shape_of_output_zero`` symbol will contain a tuple, whose elements are either integers or symbolic integers. TODO: check to see if the symbols are necessarily non-constant... or are integer literals sometimes Theano constants?? That would be confusing. cC`s}y|jj}Wntk r,|j}nXy0||g|jD]}|j|^q@}Wntk r|j|g|jD]}|j|^q}ntk r}td|ntk rx}d|jg|jD]}|j|^qt |t |t j f}t jdkr9t|n tj||j|g|jD]}|j|^qY}nX|S(NsCode called by infer_shape failed raising a NotImplementedError. Raising NotImplementedError to indicate that a shape cannot be computed is no longer supported, and one should now use tensor.ShapeError instead. The original exception message is: %ssFailed to infer_shape from Op %s. Input shapes: %s Exception encountered during infer_shape: %s Exception message: %s Traceback: %straise(RjR3tAttributeErrortdefault_infer_shapeRLR[R0RVRRTRbt tracebackt format_excRton_shape_errorRR(RkRt shape_inferRto_shapesRtmsg((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytget_node_infer_shapes0  *  & &" -c C`s|j||}|jrt|jjtr|jjd|jjkr|jsZt|j}x<|jD]1}t |dddkrm|j |dqmqmW|j |}t |t |jkstxt||jD]\}}t|dsqnt|j|} t} xrt|jD]a}| |} | jr/t| jjtr/| jjd|jjkr/t} ||| |RRARZRR?RR`Rt set_shape( RkRR0RRR9RNtnew_shpsR%t merged_shpstchangedtn_r((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRRs6  !  cC`sgt|jdr)|jj|r)|jSt||}yt|}Wntk r^nX|SdS(s8Return symbolic r.shape[i] for tensor variable r, int i.R^N(RZRTR^t lscalar_oneR&R/R2(RkR9RR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytshape_irs" cC`sEt|dsdStgt|jD]}|j||^q&S(s<Return a tuple of symbolic shape vars for tensor variable r.R`N(RZRWttupleRR`RY(RkRR9((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt shape_tuplescC`sYg}xL|jD]A}y|j|j|Wqtk rP|jdqXqW|S(sReturn a list of shape tuple or None for the outputs of node. This function is used for Ops that don't implement infer_shape. Ops that do implement infer_shape should use the i_shapes parameter, but this default implementation ignores it. N(RRKR[RHRW(RkRti_shapesRgR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRI s cC`s|d k st|dkr%|jSt|tkrXt||krXt|}nt|tkst|tj st|tj r|j dkr|dkrd}|t j j|7}t|ntj|ddSt|ttfkrt|n|jr)t|jjtr)|jjdjr)t|jjdjjtjr)|j dksvtt|jjjdkstt|jj|jjj}t|dkst|d}yt|}Wntk rq)X|jjdjjd}|j||}n|jj t!j"j#krlt$|jddrht%d|n|St%d|t|t$|d d d S( sReturn a symbolic integer scalar for the shape element s_i. The s_i argument was produced by the infer_shape() of an Op subclass. var: the variable that correspond to s_i. This is just for error reporting. iis'There is a negative shape in the graph!RXRR`sShape element must be scalarsUnsupported shape elementRTN(&RWRaRXRTtfloattintRRR(tintegertndarrayR`Rtutilstget_variable_trace_stringRR5RRZRRVRRjRRLR%R>tidx_listRR/R2R[RXRoRtinteger_dtypesRR(Rkts_iRROR0R9R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytunpacksH  $!  "!  cC`s |s$||jks$tdn|dkr@||j|R4Rotprintingt debugprintRtgetvalueRRZRTR^RKRXRfREtequalsR5R1tshape_of_reverse_indext setdefaulttsettadd(RkRRRQtsiot shape_varsR9tsv((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRS\s.   %!{ c C`s||jks!td|f|j|}|dkr>dS||jkr]|j|}n|j||dS|jr|jr|jj|jjkr|jj|jjkrdSg}xyt|D]k\}}|dkr|r|j||q|jrht t |jddt rh|jjj |krh|jjd||fkrh|j||qt ||t tfr|j||qt ||t tfr|j||q||||kr|j||q||tjjj||gkr$|j||q|j||qWtgt|jD]v}t|jd p|jj| r|jj| p|jj||p|jjtj||dt^qLstt||j|RRbRjRWRRRZRRRXRoRR4R5RRtdataRYR RS( RkReRRRR9RNtsh_idxtshRftdtcasted_dR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRsD  *!cC`s$||jkr|j|n|j||x!|j||fgD] \}}tt|ddtrF|jj }|j||} | j |krqFn| j r| j j d|j dkrt| j jtr| j jj |jj krqFn|j dt jjj| gkr?td||||fn||j|RaRARRRjR&R9RLttheano.scan_module.scan_utilsRR( RkRRtdim_xtdim_ytsxtsytdxtdytopxtopyR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt same_shapes6        N(RRRRPRRRYR[RIRfR?RSRyR}R~RRRRRRWR(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRFSs"V " )   C 0 O      9 CtShapeOptimizercB`s eZdZdZdZRS(s?Optimizer that serves to add ShapeFeature as an fgraph feature.cC`s|jtdS(N(RnRF(RkRe((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRrscC`sdS(N((RkRe((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs(RRRRrR(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs tUnShapeOptimizercB`seZdZdZRS(s3Optimizer remove ShapeFeature as an fgraph feature.cC`s7x0|jD]%}t|tr |j|q q WdS(N(RRRFtremove_feature(RkRetfeature((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs(RRRR(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRstShapeOptg?t fast_compilet UnShapeOpti c`sfd}|S(Nc`sct|jstSt|jdkrstg|jdD]%}|jj|jdjjk^q<sstnt g|j D]%}|jj|jdjjk^qstSfd}t g|j D]0}|j ot|j jp||^qstSd}xst |j D]b\}}|jj|jdjjkr$|j ovt|j jpv||s|}Pqq$q$W|dkrCg|j D]6}|j rt|j js||r|^q}t|dkr<gt |j D]+\}}|j|jdjkr|^q}|d}qCtSn|j |}|} g} |j jj} x|j D]}|j rt|j jr|j j dj|j jdjkr|jj| jksttjjjr|j jj} g} x{t|jjD]g}|jj| r| || || r| ||}| | |}| jtj||qqW| rt|| }qn| j|j j dqu|j r||r|jj| jjksttjjjrtgt|jjD]M}|jj| r| || || rtj|j|| j|^q}|rtt||}qtn|j j dj j d}|j|j j djkr|j j dj|j}|jdg|tt|j}n|j j|}t||| j|qu| j|quW|| |<|jdt | }t|j||S(se elemwise(alloc(x, shp), ..., y.TensorType(BROADCAST CONDITION)) -> elemwise(x, y.TensorType(BROADCAST CONDITION)) elemwise(dimshuffle(alloc(x, shp)),... ,y.TensorType(BROADCAST CONDITION)) -> elemwise(x.dimshuffle(...), y.TensorType(BROADCAST CONDITION)) BROADCAST CONDITION: the condition is that the one input that are not to be optimized to have the same broadcast pattern as the output. We can change the alloc by a dimshuffle as the elemwise already have the shape info. The dimshuffle will be faster to exec. iic`sEt|jjoD|jjdjoDt|jjdjjS(Ni(RRRjRL(R9(tAllocOPt DimShuffleOP(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytdimshuffled_allocsiRR(!RRjR?R>RRERTR^RaR@RLRRReRRRR`RoRt experimentaltlocal_alloc_elemwise_assertRRRRKR5RRR\t dimshuffleRRRR(RRR9Rt assert_op_idxR0tl2tlt assert_optcmp_optnew_iRRRtcondti_shptcmp_shpt assert_condt alloc_inputt nb_dim_to_addtr_iR (RRt ElemwiseOP(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_elemwise_allocsB5@   %  & <   ((RRRR((RRRs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_elemwise_alloc_opstlocal_alloc_elemwisec C`st|d s8t|jtj s8|jtjkr<tSg}g}xm|jD]b}|jr|jjtjkr|j |jjd|j |jjdqR|j |qRW|stS|j|}x5|D]-}|j |j krtj||}qqWi||j d6}x|j dj D]\}}t|dr.t|jtjr.|jtjk r.|j} || |<|j| } |j dj | jj d_ t j| j} | sq.n|j| q.q.W|S(sv f(fill(a, b), fill(c, d), e) -> fill(c, fill(a, f(b, d, e))) f need to be an elemwise that isn't a fill. Rjii(RZRRjR5RR6R?RLRRKRTRRtlocal_fill_sinkRtupdate( RtmodelsRLRtctmodelt replacementstclienttcl_idxt client_inputst new_clientR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRys>   cC`s?|jtjkr;|j\}}|j|jdjkrF|g}n|jj|jdjjkrtj||jdjjg}na|jj|jdjjkrt |||j d|j}t |jd||g}ndS|dj|jdjks7t d|djd|jdjd|f|SdS(sfill(s,v) -> alloc(v, shape(s)) This is an important optimization because with the shape_to_shape_i optimization, the dependency on 's' is often removed. iRXNRgtorigR( RjR5R6RLRTRR^RYRXRhReRRa(RRRPRgR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_fill_to_allocs  %    Rg)\(?RgRQ?cC`sH|jtjkrD|j\}}|j|jdjkrD|gSndS(sfill(s,v) -> v This optimization is only needed in FAST_COMPILE to make the code more readable. Normally, it is done by the local_fill_to_alloc opt. iN(RjR5R6RLRTR(RRRP((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_fills cC`sS|j}t|tstS|jd}|jd}|j|jkrO|gSdS(s If the input type is the same as the output type (dtype and broadcast) there is no change in the shape of the input. So this is just a simple copy of the input. This is not needed. iN(RjRR.R?RLRRT(RRjRtoutput((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_allocs   c C`s|j}t|tstS|jd}|jd}|j|jkrO|gSt|dg}x6|D].\}}|dkrht|jtrhdSqhW|jd}d}xKtt ||j D]0}t ||dt dkr|d7}qPqW||} |dkrt | |j kr|j ||j krE|} n||g| } dg|ttt | } t| jj | | gSdS(sIf the input type is the same as the output type (dtype and broadcast) there is no change in the shape of the input. So this is just a simple copy of the input. This is not needed. (as local_useless_alloc) Also, it will canonicalize alloc by creating Dimshuffle after the alloc to introduce the dimensions of constant size 1. See https://github.com/Theano/Theano/issues/4072 to know why this is needed. iRRNiRJR(RjRR.R?RLRRTRRR>R`R1RR^RRR( RRjRRRRR9t output_shapet"num_dims_with_size_1_added_to_lefttnew_output_shapetinnertdimshuffle_new_order((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_canonicalize_alloc s2       !  cC`s<t|jtjr8tj|jd|jdjgSdS(s This convert AllocEmpty to Alloc of 0. This help investigate NaN with NanGuardMode. Not registered by default. To activate it, use the Theano flag optimizer_including=alloc_empty_to_zeros. This also enable the GPU version of this optimizations. RXiN(RRjR5t AllocEmptytzerosRLRRX(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_alloc_empty_to_zeros@s RgfffffH@talloc_empty_to_zeroscC`si|jtjkret|jds(dS|jj}|j|jd}t|j d||gSdS(NRRi( RjR5R\RZReRRRRLRR(RRRR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_shape_to_shape_iSs cC`suy|jj}Wntk r$dSX||jkrqt|jtsLt|j|}|j||jj gSdS(N( ReRRRHRRRjR&RaR[R9(RRRt replacement((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_track_shape_ids  cC`sYt|jtrU|jd}|j s?t|jjt rCdS|jjjsVdS|jjd|jdkrNt|jjjt|jjkrN|j d}|jjd}|j |j kr|j |j }n|j |j kr|gS|j |j kst|j|jjd|jjd}tj||jgSqUdSndS(s7 Subtensor(SetSubtensor(x, y, idx), idx) -> y iNii(RRjRRLRRtset_instead_of_incRZRcRRXR6RTR^RaR5R]R\(RRR%Rt x_subtensor((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_subtensor_inc_subtensorus$  ' &c C`st|jtr!|jj}ndSg}d}x t|D]\}}t|tjr|j|}t|t jj j kr|j }n|dkr|jdj |r|j||d7}qPdSq>t|tr|tdkrPdSq>t|ttjfrD|dkrP|jdj |rP|j|qPq>tdq>Wt|dkrjdSt|jdj}g|D]}||kr|^q} |jdjt| gSdS(s Remove broadcastable dimension with index 0 or -1 a[:,:,:,0] -> a.dimshuffle(0,1,2), when a.broadcastable = (False, False, False, True) a[0,:,-1,:] -> a.dimshuffle(1,3), when a.broadcastable = (True, False, True, False) Niiiscase not expected(ii(ii(RRjRRcRR"tScalarRLRTRoR#tScalarConstantRcR^RKtsliceRWRR(R_RR>RR`RRZ( RR0t remove_dimtnode_inputs_idxtdimtelemt dim_indextall_dimRt remain_dim((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt*local_subtensor_remove_broadcastable_indexs4       %tfast_compile_gpucC`s|jd}|j s)|jjtkr-dSt|jtry|jj\}Wntk rhnXt|tj t j fr||jd}}|j |kst qn&t|jtr|jd}ndSt|ttjfr|jj|gSt|trW|jdkryrt|dt}t|tjrVt|}ny|jj|g}Wntk rtdnX|SWqTtk rqTXq|jdkrHt|t jrHtttt|j}tg|D]}|jj|^q}t|jd|t j||jdj }|gSt!dnt|t"ryl|jj#|jdt$d}t|jj|}t|j|t j||jdj }|gSWqtk rqXn t!ddS(s Replace all subtensor(make_vector) like: [a,b,c][0] -> a [a,b,c][0:2] -> [a,b] Replace all AdvancedSubtensor1(make_vector) like: [a,b,c][[0,2]] -> [a,c] We can do this for constant indexes. iNiRJsBad user graph!scase not expectedt allow_partial(%RLRRjRRRRcRR"RR5RRTRaRRR(R_RR`R/RR^t IndexErrorR2RRRRcRRtpatternbroadcastR^RRtget_constant_idxR?(RRR0told_idxRPR Rt const_slice((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_subtensor_make_vectors^    !)   cC`s t|jtjr|jdj}|jjtjj krt |j dkr|j d|j dkrtj |j dd|dt }t|jd||gSq|jjtjjkr3t |j dkr3|j d|j dkrtj|j dd|dt }t|jd||gSq|jjtjjkrnt |j dkrn|j dgS|jjtjjkrt |j dkr|j dgS|jjtjjkrt |j dkr|j dgSt|jjtjrHt |j dkrHt|j dtjrtj|j ddt }t|ts|dkrtj|j dd|dt gS|j dj|jdjgSqnt|j dtjrtj|j ddt }t|tsE|dkrtj|j dd|dt gS|j dj|jdjgSqEqqt|jjtjrt |j dkrt|j dtjrtj|j ddt }t|ts|dkr|j dj|jdjgStj |j dd|dt gSqnt|j dtjrtj|j ddt }t|ts|dkr|j dj|jdjgStj |j dd|dt gSqqqt|jjtjrt |j dkr|j d|j dkrtj|j dd|dt gSqndS(s eq(x,x) -> 1 neq(x,x) -> 0 mul(x) -> x add(x) -> x identity(x) -> x and(x,1) -> x and(x,0) -> zeros_like(x) or(x,0) -> x or(x,1) -> ones_like(x) xor(x,x) -> zeros_like(x) iiiRXR RJN(RRjR5RRRXRRoR"RR>RLt ones_likeRRtneqR5tmulRotidentitytANDtTensorConstantR1RR6tORtXOR(RRXR t const_val((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_elemwisesn-" -" --  '  * ! !cC`st|jtjrt|jdkr|jd}|jrt|jjtjr|jjd}|jjd}|j|}t|j d|tj tj ||j dj |}t|j d|g||gSndS(s,unary(alloc(x, shp)) -> alloc(unary(x), shp)iiN( RRjR5RR>RLRR.RRR]RYRX(RRRtshpRPR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_alloc_unarys* !(cC`st|jtj s/t|jjtj r3dS|jd}|j st|jjtj st|jjjtj rdS|jjj |jjjj kr|gSdS(scast(cast(x, dtype1), dtype2) when those contrain: dtype1 == dtype2 TODO: the base dtype is the same (int, uint, float, complex) and the first cast cause an upcast. Ni( RRjR5RRR"tCastRLRto_type(RR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_cast_casts   !cC`stjtjftjtjftjtjftjtjftj tj ftj tj ftj tj ff}|j d}t |jtjsdS|j st |jjtj rdS|jjj}|jj}x*|D]"}t|||r|jj SqWdS(sy Check for two consecutive operations that are functional inverses and remove them from the function graph. iN(R#tDeg2RadtRad2DegtCoshtArcCoshtTanhtArcTanhtSinhtArcSinhtConjtNegtInvRLRRjR5RRRtis_inverse_pair(Rt inv_pairsRtprev_optnode_optinv_pair((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_func_invs$  #  cC`sbt||d}t||d}t||d}t||d}|rX|pa|oa|S(sj Given two consecutive operations, check if they are the provided pair of inverse functions. ii(R(R R R t node_is_op0t node_is_op1t prev_is_op0t prev_is_op1((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR s tAssertcB`seZdZeZd Zidgd6ZeZddZ dZ dZ dZ dZ d Zd Zd Zd ZRS(s Implements assertion in a computational graph. Returns the first parameter if the condition is true, otherwise, triggers AssertionError. Notes ----- This Op is a debugging feature. It can be removed from the graph because of optimizations, and can hide some possible optimizations to the optimizer. Specifically, removing happens if it can be determined that condition will always be true. Also, the output of the Op must be used in the function computing the graph, but it doesn't have to be returned. Examples -------- >>> import theano >>> T = theano.tensor >>> x = T.vector('x') >>> assert_op = T.opt.Assert() >>> func = theano.function([x], assert_op(x, x.size<2)) ROisTheano Assert failed!cC`s ||_dS(N(RO(RkRO((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRm scC`s/|jj|t|ds+d|_ndS(NROsTheano Assert failed!(t__dict__RRZRO(Rktattrs((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt __setstate__ scG`st|ts!tj|}ng|D]}tj|^q(}tjg|D]}|jjdk^qPswtt j ||g||jgS(Ni( RRR5RSR(RERTR`RaRR(RkRctcondsRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR! s "4cC`sC|\}|d}||d(RkRR8((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR; scC`s%dggdggt|jdS(Nii(R>RL(RkR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytconnection_pattern scC`s|d}|d}g}|d} |jjddjdd} xTtt|dD]<} || d} |j| dj} |jdtq\Wdj|}d tS( Nitfailt"s\"s s\nisgif(!((npy_%(dtype)s*)PyArray_DATA(%(i)s))[0]){PyErr_SetString(PyExc_AssertionError,"%(msg)s");%(fail)s}ss %(check)s Py_XDECREF(%(out)s); %(out)s = %(value)s; Py_INCREF(%(value)s); ( RORRR>RLRXRKR+RC(RkRRtinamestonamesR,RcR%tcheckRROR0R9RX((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR1 s   ! cC`sdS(Nii(ii((Rk((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR'1 scC`s |dgS(Ni((RkRt input_shapes((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR34 s(smsg(RRRRt_f16_okR>tview_mapR?t check_inputRmRR!R&R;RR1R'R3(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs        cC`st|jtrg}xq|jdD]b}y;t|}d|jksV|dkrf|j|nWq&tk r|j|q&Xq&Wt|dkr|jdgSt|t|jdkrt |jd|}t |j d||gSndS(Nii( RRjRRLR/R`RKR2R>RRR(RRRtconstR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_remove_useless_assert> s  cC`s$t|jtsdS|jdgS(sAn optimization disabled by default that removes all asserts from the graph. Notes ----- See the :ref:`unsafe` section to know how to enable it. Ni(RRjRRL(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_remove_all_assertY s RR$tunsafetuse_db_name_as_tagRRtuselessc C`s@t|jdkrdSy|jjj}Wntk rEd}nXt|jt j r<|jj }t |ddt j jt j jfkr<|jdjj}g}x/|jD]$}|jj|kr|j|qyt|dt}t|jr+|jt jt j|||jn]|dkr;dS|jt jt j||gt|jD]}|||^qfWqtk rt|t jr|jt j||q|j|qXqW||jkr9|j|g}|dj|jdjkrdSt|jd||Sq<ndS(sThis explicitly upcasts constant inputs to elemwise Ops, when those Ops do implicit upcasting anyway. Rationale: it helps merge things like (1-x) and (1.0 - x). iNtoutput_types_preferenceiRJ( R>RReRRtshape_iRHRWRRjR5RRRtscaltupgrade_to_floatt upcast_outRTRXRLRKR/RRER^t shape_padleftRYR`R]RR2RR( RR)Rt output_dtypeRR9tcval_iRRg((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt%local_upcast_elemwise_constant_inputs sL        3 cC`st|jtsdS|jjtkrmy-t|jddt}|dkrTdSWqmtk ridSXn|jdj |jdj ks|jdj |jdj krdSt |jd|jj }t d|Drt|jdsdS|jjj|jd|jds#dSt d|jj DrM|jdgSt|jj |jd}t|j||gSdS(sY Remove IncSubtensor, when we overwrite the full inputs with the new value. NiRJics`si|]_}t|to`|jdko`|jdko`|jdkp`tj|jdtdkVqdS(RJiN( RRtstartRWtstoptstepR5R1R(R;R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys sRRcs`s|]}|jdkVqdS(N(R3RW(R;R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys s(RRjRRR?R/RLRR2R`R^RRcRERZReRRRRRR(RRtidx_cstR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_inc_subtensor s6         cC`st|jtr|jjr|jdjrt|jdjjtrt|jdjjjtj r|jdj}d}d}|jdjrt|jdjjt r|jdj}|jd}nP|jdjr t|jdjjt r |jdj}|jd}ndS|jd|jdksX|jd|jdkr\dSt |jd||jd}t |j||gSdS(s AdvancedIncSubtensor1(x, x[ilist]+other, ilist, set_instead_of_inc=True) -> AdvancedIncSubtensor1(x, other, ilist, set_instead_of_inc=False) iiNi(RRjRRRLRRRR"tAddRWRR!RR(RtaddntsubntotherR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_set_to_inc_subtensor s. " cC`s+t|jtr't|j|jj}t|}x|dddD]n}t|tr|jdkr|j dkr|j dkst j |j dtdkr|d8}qJPqJW|t|kr't|| }tj|| d}||jd|}t|j||gSndS(s6 Remove Subtensor of the form X[0, :] -> X[0] NiRJicS`st|tjS(N(RR5R(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR9 si(RRjRRRLRcR>RR1RWR2R3R5R1RtcollapseRR(Rtslicest last_sliceRtsubtenstsl_insR%((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_slice" s  -   c C`st|dsdSt|jds)dS|jjj}t|jtrg|jj|jdt dt }xqt |D]c\}}t|t st S|j dk r|j dkrt S|jdk rx|jdkrxt SqxWxt |D]t\}}||jd|}t|jttjfrqtj}yt|dt }Wntk rZnX|j|kr`t Sqt|jtjrJ|j}|jrt|jjtjr|jjd}n8|jrt|jjtjr|jjd}nt St|jj dkst!t|jj d ks7t!||kr`t Sq|jdkr\qt SqWnNt|jt"ry%t||jdddt }Wntk rt SX|jd}t|tj#r|j$}t%||krt Stj&|tj'|krt Sq|jdk rt|jjtj(ry%t)d |jj\} } } Wntk rvt SX| dkrt S| |krt S| dkrt Sqt Snt S|jdgS(s Remove Subtensor/AdvancedSubtensor1 if it takes the full input. In the AdvancedSubtensor1 case, the full input is taken when the indices are equivalent to `arange(0, input.shape[0], 1)` using either an explicit list/vector or the ARange op. ReNRRRRJiiRtint8tint16tint32cS`st|dtS(NRJ(R/R(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR s (sint8RBRCsint64(*RZReRRR[RRjRRRLRRRR?R1RWR3R2RR(R_RtmaxsizeR/R2RRRR5RRRbRTRXRaRRRcR>R@tarangetARangeR( RR[tcdatatposR0t length_postlength_pos_datatlength_pos_shape_itlengthR1R2R3((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_subtensor@ s                 '     c C`sht|jtrd|jd}|j s>t|jdkrBtSt|jjtj rt|jjdkr|jd}|j|jjd|}t |j ||jj|}t |j d|jdg||gSt|jjtj rg}t g|jjD]}t |jjdk^qr|jd}g|jjD]}|j||^qT}t |j d||jj|}t |j d|jdg||gSt g|jjD]'}t |jj|jdgk^qr|jd}g}x|jjD]}t |jjdkrZ|j|j||q |j dj|jkr|j|q |j|jdg|j djq Wt |j d||jj|}t |j d|jdg||gSnt|jjtjrdt|jjdks5tg}d}xVt|jjD]B\}} t| trT|||j|fg7}|d7}qTqTWxPtt|jjt|jD]*}|||j|fg7}|d7}qW|j|jjd|jd} t |j d| tj|| } t |j d|jdg| | gSndS(s unary(x)[idx] -> unary(x[idx])#any broadcast pattern. Handles the following unary ops: elemwise(x,...)[idx] -> elemwise(x[idx],...) when x,... are broadcasted scalar or not broadcasted at all rebroadcast(x)[idx] => rebroadcast(x[idx]) iiRN(RRjRRLRR>RR?R5RRRRERRTR^R`RKRt RebroadcastRaRRcRR( RtuR0tx_idxR RR9tnew_axisR{Rtsubt_xt rbcast_subt_x((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_subtensor_lift sf  0 !7 +!: %! +#!cC`s,tttttg}t|tk r9td|nt||\}}t||\}}t|tk ro|dkrL|j ||j } t j t j|d|d| } t j t j|||d| } t j t j|d| d| } |j r9t j t j|j d|d| } nt|| } | S|j ||j } |jd||j } tjjrtjdnt j t j|d| | } t j t j|d|d| } t j t j|||d| } t j t j|d| d| } |j rYt j t j|j d|d| } nt|| } | Sn|j|j } |j |j } |j |j d}t j|j |j |j |j}t j|j |j|j |j}|j |j d|j }t j t jt j|dt j| d| dt j||j}|j |jd|j }t j||j}t j|d}|j|j|j d}t j t jt j|dt j| d| dt j|j d|}t j|j |j|j |j d}t j|j |jd|jd|j }t j|j |j|j |j }t j t j||dt j t j|d||t j t j|d||}t j t j||dt j t j|d||t j t j|d||}t j t j||d|| }t j t j| dd|}t j t j| dd|}t||}t||}t||}t||}t||}t||}t|||g\}}}t|||SdS(so This function merges two slices into a single slice. The code works on the assumption that: a) slice1 is actually a slice and not an index, while slice2 can be just an index. b) the two slices **have been applied consecutively** on the same tensor The output slice is **not** in canonical form, but actually just a slice that can be applied to a tensor to produce the same output as applying the two consecutive slices. ``len1`` is the length of the tensor **before** applying the first slice, while ``len2`` is the length **after** applying the first slice. sGFirst provided slice should actually be of typeslice and not an index !iisYour current code is fine, but Theano versions prior to 0.5rc2 might have given an incorrect result. To disable this warning, set the Theano flag warn.subtensor_merge_bug to False.iN(tlocal_abs_mergetlocal_mul_switch_sinkR0tlocal_useless_switchtconstant_foldingRTRRRRWR1R3R5tswitchtletgetltRR,R2Rtwarntsubtensor_merge_bugRtminimumtand_tgttmaximumR+(tslice1tlen1tslice2tlen2tlist_opttsl1treverse1tsl2treverse2tvaltp_valtn_valtflentp_steptn_steptpp_starttpp_stoptpn_stoptpn_starttnp_stoptnp_starttnn_starttnn_stopR1R2R3((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytmerge_two_slices' s   %%& +  !%%& +&&* "& $%!!cC`st|jtr|jd}|jrt|jjtr|jjd}t|jj|jjj}t|j|jj}y*|jjj |}|jjj |}Wn#t k r|j }|j }nXg}d}d} x| t |krw|t |krw|| } t | tkr]|jt| || |||||d7}n |j| | d7} qW|t |kr|||7}n||| 7}t|}t|} tj|d} | || } |jd}t||jdg| | j |j kr| j|jks6t| j|jksNttj| |j} t||jdg| n| gSndS(s Refactored optimization to deal with all cases of tensor merging. Given a subgraph of the form Subtensor(Subtensor(u)), the optimization expresses all slices in a canonical form, and then merges them together. iicS`st|tjS(N(RR5R(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR sN(RRjRRLRRRcReRRR[RHR\R>RTRRKRzRR;RRRXRaR`R5RR^(RRORtslices1tslices2txshapetushapet merged_slicestpos_2tpos_1RcR>R?R%torig_out((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_subtensor_merge sV     '       cC`sut|jtstS|jd}|jdkr6tSt|jjtjsRtSt |j|jj }|jjd}|jjd}t |t |kst |j |j }g}g}xtt||D]\}\} } ||krH|jj ||kr8|jj||r8|jtdqH|j| nt| | \} } t| tk rrq| j| j} | jdkrtj| | j} n|| g7}qW|t|}||t |7}|j t |krtStj||}t|ttfkr-|g}n|dj|jdjkrqtj|d|jdj|d alloc(val[...]) alloc(val)[x:y] -> alloc(val) This can be seen as a lift, but it also reduce the number of computation/memory. iiN(RRjRR?RLRRWR5R.RRcR>RaR`RRARTR^RKRRR2R1R3t ceil_intdivRZR]RRR(RROR<Rltdimst n_added_dimstnw_dimst val_slicesR9tslRtcslt_tnw_dimtnw_valRg((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_subtensor_of_alloc sJ  (  'c C`st|jtsdS|jdj sGt|jdjjtj rKdSt|jdjdkrkdS|jdjjd}|jdjjd}t |j|jj }t |j dt|}|| }||}|j dkr?t||j dkr?||j d t dddf||j d}n|jt|}|ro|jt|n|}t|jd||gtj||} t|jd|jdg| | gS(sb This optimization translates T.dot(A, B)[idxs] into T.dot(A[idxs_a], B[idxs_b]), where idxs_a and idxs_b are defined appropriately. idxs_a is the first A.ndim-1 entries of idxs, and idxs_b is the remaining entries of idxs (if any), modified to skip the second-to-last dimension of B (because dot sums over this dimension). Niii(RRjRRLRR5RR>RRRctminR`RRWt __getitem__RZRRR( RRtbRct num_a_indicest a_indicest b_indicesta_subtb_subR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_subtensor_of_dotF s*   (6!!c`s`fd}|jtjkr\|jdjg|jD]}||r;|^q;}|r\g|jD]}||si|^qig|D]}|jjd^q}tj|}t|jd||}x~|D]v}|jkst|j|jjdjkst|jj||jjd}t|j|jj|qW|gSndS(sK When using Subtensor, gradient graphs can be ugly. If we ask for grad(f(a[0]), a), we are going to get something like IncSubtensor(Elemwise{second}(a, 0), g(f(a[0])), [0]) This might be ugly, but at least it's as fast as you could want. If we ask for grad(f(a[0], a[1], a[2]), a), it's much worse... Elemwise{Add} IncSubtensor(Elemwise{second}(a, 0), g(f(a[0])), [0]) IncSubtensor(Elemwise{second}(a, 0), g(f(a[1])), [1]) IncSubtensor(Elemwise{second}(a, 0), g(f(a[2])), [2]) This is much worse because this time we have to produce 3 matrices the size of 'a', just so we can add them together. This Op rearranges IncSubtensor's that all work on the same initial argument (here, Elemwise{second}(a,0)) into a chain. The advantage of the chain structure is that each one can be optimized later in the pipeline to operate inplace. Ideally, the op will do something like this: # # add(x, incsubtensor(b, c), incsubtensor(b, d)) # -> incsubtensor(incsubtensor(add(x,b,b), c), d) c`sY|joXt|jjtttfoX|jkoXt|jdkoX|jjj S(Ni( RRRjRRRRTR>RR(R9(R(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytmovable s  iiN( RjR5RoRRTRLRRRa(RRR9tmovable_inputstmiRtnew_addttip((Rs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_IncSubtensor_serialize s ! (%$ "t pre_local_IncSubtensor_serializegGz?cC`st|jtr|jj r|jj}|jj|jjdtd|jjd|}||j }t |j dj dt}||j _ t|j ||gStS(s) Also work for GpuIncSubtensor. RRtdestroyhandler_tolerate_aliaseditnan_guard_mode_check(RRjRRRRRcRRRLRRttagRRR?(Rtdtatnew_opRRl((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_inplace_setsubtensor s     Rtfailure_callbacki<cC`sXt|jtrT|jj rT|jj}||j}t|j||gStS(s2 Also work for GpuAdvancedIncSubtensor1. ( RRjRRt clone_inplaceRLRRR?(RRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_inplace_incsubtensor1 s Rtlocal_incsubtensor_of_allocscC`st|jtttfr}|jj r}|jd}|jd}y#t|dtdkrd|gSWq}t k rydSXndS(s+ IncSubtensor(x, zeros, idx) -> x iiRIN( RRjRRRRRLR/R?R2(RRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_incsubtensor_of_zeros s       tlocal_setsubtensor_of_allocscC`st|jtr|jjr|jd}|jd}yt|dt}Wntk rbdSXyt|dt}Wntk rdSX||kr|gStSndS(sN SetSubtensor(x, x[idx], idx) -> x when x is constant or alloc. iiRIN(RRjRRRLR/R?R2(RRRt replace_xt replace_y((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_setsubtensor_of_constants' s      c C`st|jtsdS|jd}|j sCt|jjt rGdS|jd}|jjd}|jjd}|jjd}||k rdS|jjj rtj|dt dkrdStj tj tj ||j dtj||j d g}|jjj||ddsP|jtj|j d|j dntd||}t|||j|jdjkr|gStj||jdj}t|||gS(sxOptimize the possible AdvSub1(AdvIncSub1(...), ...). AdvancedSubtensor1(AdvancedIncSubtensor1(0s, y, idx), idx) -> y AdvancedSubtensor1(AdvancedSetSubtensor1(x, y, idx), idx) -> y Notes ----- This opt add AssertOp. Otherwise, it would remove shape and index error. If you want to get rid of them, see the :ref:`unsafe_optimization` section. NiiiRIsIBad indexing or shapes in a AdvancedIncSubtensor1 that was optimized away(RRjRRLRRRR5R1R?RER`R\R\R[ReRRRRKRRRRXRRY( RRR0tidx2RRRRtr2((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_adv_sub1_adv_inc_sub1J s4    E*    c C`st|jtttfr|jd}|jd}|jd}|jd k rt|jjtj r|jjd}y|j j }Wnt k rt SX|j}|j}t|jtrt|jj||}nTt|jtrt||}n0t|jtr(t||}n tdd} ||krf|j|j |jd| n|j|jkrtj||j|j}||kr|j|j |jd| qntf|j|j|j} gt|jD]} | | r|||d| d |  r||| dkrtjtj|j| dtj|j| |j| ^q} t| dkrd } t| || }n|j|||}t |j!||gSnd S( s Replaces an [Advanced]IncSubtensor[1], whose increment is an `alloc` of a fully or partially broadcastable variable, by one that skips the intermediate `alloc` where possible. iiisShould never happen!t local_useless_incsubtensor_allocs %s: add `xi`s %s: add `y`RRs*`x[i]` and `y` do not have the same shape.N("RRjRRRRLRRWR5R.ReRRRHR?R[RRRcRR RRR`R-RR^Rtor_RR\R>RRR(RRRR9tzRRR[RtxiRtz_broadRRROR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt!local_useless_inc_subtensor_alloc sT     '       YcC`st|jtjr|jd}tj|j|jdjkrK|gSi}xFt |jj j D],\}}|j||krj||| Elemwise(Rebroadcast(x)) Rebroadcast(Rebroadcast(x)) => Rebroadcast(x) iiRN(RjRR5RNR?RLRRR>RZRRRRRRR!tcopyR(RRjRRt rebroadcastedRgRtiinput((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_rebroadcast_lifts(   -$ $cC`st}x|r|jrt}tjjjj|j}|rjt|dksWt |d}t}n|jr tjjj j|j}|rt|dkst |d}t}qq q W|S(s Apply as many times as required the optimization local_useless_rebroadcast and local_rebroadcast_lift. Parameters ---------- rval: a Variable Returns ------- A Variable (the same if no optimization can be applied) ii( RRR?RoRR RRR>RaR(RgRVtrval2((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytapply_rebroadcast_optKs"      cC`sGt|jtjsdS|jd}t|dkrC|dgSdS(sIJoin(i, x) => x Remove Join() when only one element is joined. Nii(RRjR5tJoinRLR>(Rttensors((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt local_join_1ps  cC`st|jtjsdSg}yt|jddt}Wntk rPdSXxhtdt |jD]N}|j|}t|t j r|j j |dkrqjn|j|qjWt |t |jdkrt |dkrdStj|jd|}|jd}|j|jkr-dSt|j||j|jkr|j|jksgt|j|jksttj||jdj}nt|j||gSdS(spJoin(i, x, y, empty) => Join(i, x, y) Remove empty inputs to joins. The empty inputs can be anywhere. NiRJi(RRjR5RR/RLRR2RR>RoRRR\RKRCRRXRRTRaR`RR^(RRtjoin_idxR0RR R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_join_emptys6    ( cC`swt|jtj s,|jdjdkr0dS|jdg}xtdt|jD]}|j|}|j rt|j jt r|dj rt|dj jt r|j j|dj jkr|dj j|j j}|j j||d Join(0, make_vector12, ...) Merge MakeVector inputs to Join. This can make the join completly disapear with the local_join_1 opt. iiNii(RRjR5RRR`RLRR>RRRRKRC(RRR0RtinpsR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_join_make_vectors$ ,   c C`st|jtjjr t|jjtjjj r |jj dkr |j d}|j d}|j r t|j jtjr t|j jjtjjjr |j j d}|j r t|j jtjr t|j jjtjjjr t|j j dkr |j j \}}t|j jtjjr|j jjd krt|j jtjjr|j jjd kr|j j d}|j j d}tjtj|tj|jdd}|j|jkrtj|d|j}n|gSq q ndS( s This optimization detects T.sqr( W.dimshuffle('x',0,1) * G.dimshuffle(0,'x',1) ).sum(axis=(1,2)) and converts this to T.dot(T.sqr(G), T.sqr(W).sum(axis=0)). iiiRRRXN(ii(Rii(iRi(RRjR5RItSumRRoR"R#R6RRLRRRtSqrtMulR>RRRtsqrRRXRY( Rtin1R%tin_sqrtin_mul1tin_mul2tWtGR7((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_sumsqr2dots"0  B!9000cC`st|jtjrt|jjtjjjr|j \}}|j d}|j rt|j jtjrt|j jjtjjj rtj |dtdkr|j j d}tj|}|j|jkrtj|d|j}n|j|jkrdS|gSndS(sK This optimization detects exp(a)-1 and converts this to expm1(a). iRJiRXN(RRjR5RRRoR"R#tSubRLRRtExpR1R?texpm1RXRYRT(RRtin2R%tin11R7((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt local_expm1s Btlocal_remove_switch_const_condc C`st|jtjrt|jjtjjrtj|j ddt }t |t j krp|jdkst|t jr|dkr|j d}n |j d}|j|jdjkrtS|j|jdjkrtj||jdj}n|}|j j|jdj jkrg}xtt|j j|jdj jD]\}\}}||kr|j|j|qT|j dj j|s|j|j dj|qT|j|j dj|qTWtj||}n|}t|j|||gS|j d|j dkr|j |j dj krT|j dgStj||j d}t|j|j d||gS|j d} |j d} |j d} | jrt| jjtjrt| jjjtjr| jj djrt| jj djjtrtj| jj ddt dkrtj| dt dkr| | jj dkr| j |jdj kst| gStStS(sP This optimization makes the following changes in the graph: T.switch(cond,left,right) --> if cond is constant and cond == 0: right if cond is constant and cond != 0: left if left is right -> left T.switch(le(shape_i{id}(X), 0), 0, shape_i{id}(X)) -> shape_i{id}(X) iRJii( RRjR5RRR"R#tSwitchR1RLRRTR(R`R`tnumberRR?RXRYR^RRARKR\R]RR6RtLER&Ra( RRt correct_outR%tshpsR0RBRCR tlefttrighttcond_var((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRW$s` $  )     %cC`s|jtjkrtSxt|jD]\}}|jr&|jjtjkr&|j}yt|jddt dkr|j| |j|d}tj||jdg}t |j |tj|jdd|g}t |dj _t |j |j ||SWntk r"nXyt|jddt dkr|j| |j|d}tj||jdg}t |j |tj|jd|dg}t |dj _t |j |j ||SWqtk rqXq&q&WtS(s This optimization makes the folowing changes in the graph: T.mul(A,T.switch(cond,0,iff),B) --> T.switch(cond,0,T.mul(A,B,iff)) T.mul(A,T.switch(cond,ift,0),B) --> T.switch(cond,T.mul(A,B,ift),0) A and B being several (or none) symbolic variables. This is useful because A and B may not be numerically stable and give NaN or inf values for cases where the switch returns 0. With this optimization T.grad(T.switch(...)) has the right behavior. Examples -------- x -> f(x) x -> g(x) y = T.switch(cond,f(x),g(x)) **without the optimization T.grad(y,x) -> grad(f(x),x) * grad(y,f(x)) + grad(g(x),x) * grad(y,g(x)) **with the optimization T.grad(y,x) -> switch(cond,grad(f(x),x), 0) + switch(cond,0,grad(g(x),x)) This will be particularly useful for the lazyif because we skip an entire part of the graph. iRJgii(RjR5RR?RRLRRYR/RRRR(Rtvalues_eq_approxR2(RR0R9RYtlistmultfmultfct((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRV}s@     cC`s|jtjkr(|jtjkr(tS|j}|jdjr|jdjjtjkr|jdj}yt|jddt dkr||jd|jd}t |j |tj|jdd|g}t |dj _t |j |j ||SWntk rnXyt|jddt dkr||jd|jd}t |j |tj|jd|dg}t |dj _t |j |j ||SWqtk rqXntS(s This optimization makes the folowing changes in the graph: T.div(T.switch(cond,0,iff),A) --> T.switch(cond,0,T.div(iff,A)) T.div(T.switch(cond,ift,0),A) --> T.switch(cond,T.div(ift,A),0) A being a symbolic variable. This is useful because A may not be numerically stable and give NaN or inf values for cases where the switch returns 0. See local_mul_switch_sink for more details. iiRJgi(RjR5ttrue_divtint_divR?RLRRYR/RRRR(RRR2(RRjRYtfdivR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_div_switch_sinks<$ ,   c`stjt|jtj sGt|jjjjj f rKdSt fd|j DsndS|j dj j dt fd|j dDsdStj |jg|j D]}|j j d^q|jg|j D]}|j j d^qgS(Nc3`sK|]A}|joBt|jjtjoBt|jjjjVqdS(N(RRRjR5RRR(R;R(R*(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys sic3`s%|]}|jjdkVqdS(iN(RRL(R;R(R(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys &sii(RoR"RRjR5RRtBinaryScalarOpR6RRERLRRY(RR((RR*s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_merge_switch_same_conds %# ,cC`sBt|jtjr>ytj|jddt}|dkr%ytj|jd}||jdjkr}|jdgS||jdjkrdS|jdgSdS|jdj}dg||t |}|jdj |}t |j |jd||gSWq%t k r!dSXnWq>tk r:dSXndS(snTile(x, (1,)*N) -> x This is useless tile. (1,)*N, just mean a vector with all element being 1. iRJiNR(RRjR5tTileR/RLRtget_vector_lengthR`RRRRRR2(RRRtx_ndtbroadR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_tile1s,       cC`st|jtjr|jjdkr|j\}}}t|tj|jdd}t |j |t|tj|j||d}t |||gSndS(sH Split{n_splits=1}(x, y) -> x Remove Split with only 1 split. iiN( RRjR5tSplitt len_splitsRLRRR\RR(RRRtsplitsR%tout2((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_split`s "& cC`st|jtjr|jdjrt|jdjjtjrt|jdjjdkr|j|jdjjd}t|j ||jdjj|}t|j |jdg||gSdS(s Flatten(UnaryElemwise(x)) -> UnaryElemwise(Flatten(x)) This optimization is needed by optimization nnet/sigm.py:log1msigm_to_softplus to get applied when there is a flatten. iiN( RRjR5tFlattenRLRRR>RR(RRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_flatten_liftzs  c`s%tjgfd}|S(Nc`s{tj|stS|j|jdjjd|jd}t|j||j|jdjkrs|gStSdS(sE Reshape(Reshape(shape1),shape2) -> Reshape(shape2) iiN( R t check_chainR?RjRLRRRR^(RRg(Rj(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs* (Rtlocal_optimizer(RjR((Rjs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_reshape_chains!RRcC`s|j}t|tstS|jd}|jd}|jd}|j|jkrYtS|jdkr|jdkr|j|jkr|gS|jrt|jjt r|jjd}||kr|gSn|jrt|jjt r|jj}t |dsd}nt |jdd}tg|j}xt|jD]} || } | jrt| jjtr| jjj| kr| jjd|krt|| R1RRRE(RRjRRRt shape_inputtoutput_shape_isRRt shape_matchRtoutshp_it subtensor_inpt shape_input_itinpshp_i((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_reshapesf                    c C`s8|j}t|tstS|jd}|jd}|jd}g}g}d}xst|jD]b}t||dtdt} | dkr|j dqe|j ||j | |d}qeW||jkr4|j t |||} t || t | jj|| g} t || | SdS(s Broadcastable dimensions in Reshape are replaced with dimshuffle. The goal is to avoid using reshape to add or remove broadcastable dimensions, but use dimshuffle instead, so dimshuffles can cancel out or be removed later on. For example: - reshape(x, (1, n)) --> dimshuffle{x,0}(reshape(x, (n,)) - reshape(x, (1, m, 1, n, 1, 1)) --> dimshuffle{x,0,x,1,x,x}(reshape(x, (m, n))) iiRJRIRN(RjRR3R?RLRRR`R1RKRR>RRRTR^( RRjRRRRRtindexR9RRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_reshape_to_dimshuffles.          cC`s#t|jtjr|jdjrt|jdjjtjrt|jdjjdkr|j|jdjjd|jd}t|j ||jdjj|}t|j |j||j |j dj krtj ||j dj }t||n|}|gSdS(s Reshape(UnaryElemwise(x)) -> UnaryElemwise(Reshape(x)) This optimization is needed by optimization nnet/sigm.py:log1msigm_to_softplus to get applied when there is a reshape. iiN( RRjR5R3RLRRR>RRRTRR^(RRRtre((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_reshape_liftJs *tremove_tensor_copyt CanonizercB`s}eZdZedZdZdZdZdZe dZ dZ dZ d d Zd Zd ZRS( s Simplification tool. The variable is a local_optimizer. It is best used with a TopoOptimizer in in_to_out order. Usage: Canonizer(main, inverse, reciprocal, calculate) Parameters ---------- main A suitable Op class that is commutative, associative and takes one to an arbitrary number of inputs, e.g. add or mul inverse An Op class such that inverse(main(x, y), y) == x e.g. sub or true_div reciprocal A function such that main(x, reciprocal(y)) == inverse(x, y) e.g. neg or inv calculate Function that takes a list of numpy.ndarray instances for the numerator, another list for the denumerator, and calculates inverse(main(\*num), main(\*denum)). It takes a keyword argument, aslist. If True, the value should be returned as a list of one element, unless the value is such that value = main(). In that case, the return value should be an empty list. Examples -------- >>> import theano.tensor as T >>> from theano.tensor.opt import Canonizer >>> add_canonizer = Canonizer(T.add, T.sub, T.neg, \ ... lambda n, d: sum(n) - sum(d)) >>> mul_canonizer = Canonizer(T.mul, T.true_div, T.inv, \ ... lambda n, d: prod(n) / prod(d)) Examples of optimizations mul_canonizer can perform: | x / x -> 1 | (x * y) / x -> y | x / y / x -> 1 / y | x / y / z -> x / (y * z) | x / (y / z) -> (x * z) / y | (a / b) * (b / c) * (c / d) -> a / d | (2.0 * x) / (4.0 * y) -> (0.5 * x) / y | 2 * x / 2 -> x | x * y * z -> Elemwise(T.mul){x,y,z} #only one pass over the memory. | !-> Elemwise(T.mul){x,Elemwise(T.mul){y,z}} cC`s:||_||_||_||_||_g|_dS(N(tmaintinverset reciprocalt calculatetuse_reciprocaltexternal_simplifiers(RkRR R R R ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRms      cC`s|jj||fdS(N(R RK(Rkt simplifierR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytadd_simplifierscC`s|j|j|jgS(N(RR R (Rk((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyttrackssc C`s|jdks3|jj|j|j|jgkr|jrt|jjtjr|j}|j}|j d}d|j j |j j t t |j j }|j|kr|j|jj dS|ggfSq|ggfSng}g}|j}g|j D]} |j| ^q} |j|jkrttjttjd| }ttjttjd| }nz|j|jkr| dd| dd}| dd| dd}n1|j|jkr| dd}| dd}n||fS(s This extract two lists, num and denum, such that the input is: self.inverse(self.main(\*num), self.main(\*denum)). It returns the two lists in a (num, denum) pair. For example, for main, inverse and reciprocal = \*, / and inv(), | input -> returned value (num, denum) | x*y -> ([x, y], []) | inv(x) -> ([], [x]) | inv(x) * inv(y) -> ([], [x, y]) | x*y/z -> ([x, y], [z]) | log(x) / y * (z + x) / y -> ([log(x), z + x], [y, y]) | (((a / b) * c) / d) -> ([a, c], [b, d]) | a / (b / c) -> ([a, c], [b]) | log(x) -> ([log(x)], []) | x**y -> ([x**y], []) | x * y * z -> ([x, y, z], []) iRiN(R(RRWRjRR R RR5RRLRTR`RZRRt get_num_denumRRt__iadd__Rtoperatort itemgetter( RkRtdsntdsoptdsi0tcompatible_orderR)tdenumtparenttinput2tpairs((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs6.!    %$'cC`st|t|}}| r@| r@tj|jggS|s|jrh|j|j|gS|jggdtg}n|s|dkrt|dt j st |dS|j |Sn|j |j|g|j|gS(s Utility function which takes two lists, num and denum, and returns something which is equivalent to inverse(main(\*num), main(\*denum)), but depends on the length of num and the length of denum (in order to minimize the number of operations). Let n = len(num) and d = len(denum): | n=0, d=0: neutral element (given by self.calculate([], [])) | (for example, this would be 0 if main is addition | and 1 if main is multiplication) | n=1, d=0: num[0] | n=0, d=1: reciprocal(denum[0]) | n=1, d=1: inverse(num[0], denum[0]) | n=0, d>1: reciprocal(main(\*denum)) | n>1, d=0: main(\*num) | n=1, d>1: inverse(num[0], main(\*denum)) | n>1, d=1: inverse(main(\*num), denum[0]) | n>1, d>1: inverse(main(\*num), main(\*denum)) Given the values of n and d to which they are associated, all of the above are equivalent to: inverse(main(\*num), main(\*denum)) taslistii(R>R5RSR R R tmerge_num_denumR?RRRRaRR (RkR)Rtlntld((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR^s  cC`swt|tr\t|jdddk r9|jj}n |j}|jdkrU|SdSnt|trodS|SdS(s Returns ------- object A numeric constant if v is a Constant or, well, a numeric constant. If v is a plain Variable, returns None. t unique_valueiN( RRRRRWR!RR`R(RPR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt get_constants  cC`sK|jd||j||}x#|jD]\}}||}q+W|S(s Shorthand for: .. code-block:: python self.simplify_constants(*self.simplify_factors(num, denum)) tout_type(tsimplify_constantstsimplify_factorsR (RkR)RR#RgRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytsimplifys c C`st|}t|}|dkr|dkrxtrt|}t|t|k}|j|}x(|D] }|j||j|qsW| s| r3Pq3q3Wn@x=t|D]/}||kr|j||j|qqW||fS(s  For any Variable r which is both in num and denum, removes it from both lists. Modifies the lists inplace. Returns the modified lists. For example: | [x], [x] -> [], [] | [x, y], [x] -> [y], [] | [a, b], [c, d] -> [a, b], [c, d] i(R>RRnt intersectionRR( RkR)RRR RtredotinterRP((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR%s"         c C`sgg}}gg}}xF|D]>}|j|} | dk rR|j| q!|j|q!WxF|D]>}|j|} | dk r|j| qj|j|qjW|js|r|j||dtd|} n!|j||dtd|g} g| D]} tj| d|j ^q} |rt |dkrt |dkr| rt | dkspt |j|d} | dk r| dj j | dj| r||fSn| ||fS(sB Find all constants and put them together into a single constant. Finds all constants in orig_num and orig_denum (using get_constant) and puts them together into a single constant. The constant is inserted as the first element of the numerator. If the constant is the neutral element, it is removed from the numerator. Examples -------- Let main be multiplication: | [2, 3, x], [] -> [6, x], [] | [x, y, 2], [4, z] -> [0.5, x, y], [z] | [x, 2, y], [z, 2] -> [x, y], [z] RR#RXiiN(R"RWRKR R RR?R5RRXR>RaRTt values_eqR( Rktorig_numt orig_denumR#R)RtnumcttdenumctRPtctRt first_num_ct((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR$s2        +0#  c C`s|j}||j|j|jgkr+tSt|jdksFt|jd}t|dsfdSx|j D]\}}|dkrqpnxSt t |ddt rt|jdj dkr|jdj dd}qWt |dd|j|j|jgkrptSqpW|j|jd\}}|jt|t||j\}} d} | ||r| || rtS|j|| } | jj|jjkrtjtjtjt t|jj} | | } n| j|jk| j|jk kst| j|jksFt| |jd} n| j|jkrkt| j_| gStjdj d | d |d | jd |jftSdS( NiiRRRjtcS`s5t|t|ko4tdt||DS(Ncs`s*|] \}}tj||kVqdS(N(R(RE(R;txetye((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys Ms(R>RERA(RR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytsameLs!RsCANONIZE FAILED: new, out = t,ttypes(!RjRR R R?R>RRaRZRRRRWRRR&RRTRRXR5RR"tIdentityt specific_outR:RLR)RRRRRC( RkRRjR%Rtc_idxR+R,R)RR4Rtelem_op((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR+sH   * +  cC`s&t|dd|j|j|jfS(NRsCanonizer(%s, %s, %s)(RRR R (Rk((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt__str__ns N(RRRRRmRRRRRR"R&R%RWR$RR;(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs2   v -  U CcC`s| r(| r(|rgStjdSn|dkr`tjg||D]}|j^qE}n |j}tjdd|}ttj ||ttj ||}|rtj |dkrgS|gSn|S(NiRX( R(RARWR"RRXRoR#RtmultiplyRE(R)RRR#RPR/tone((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt mul_calculatess , ( tlocal_mul_canonizercC`sI|jtjkrEtjtjdd|jdj|jdgSdS(NiRXi(RjR5tnegRR(tarrayRLRX(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_neg_to_muls"c C`st|jtjtjjfr|j\}|jr:|jjtjkr:|jj}g|D]'}t j |j j r^|j ^q^}t|dkrdSg|D]}t j |j s|^q}t|dkrd}d}nlt|dkr"|dj}|j|d}n7tj|}t|j||j}|j|}t|dks~t|j|nt|jtjjr|dkrg|D]} | |^q}n|} |dkr| j|nt| dkr t|j| | Stj| } t|j| g| | gSnt|jtjr|jr|jjtjkr|j|jjd} tj| } t|j| | g| gSndS(s sum(scalar * smth) -> scalar * sum(smth) sum(-smth) -> -sum(smth) or prod(scalar * smth) -> scalar ** size(smth) * prod(smth) prod(-smth) -> -1 ** size(smth) * prod(smth) iNi(RRjR5RRItProdRLRRR(RERTR^RR>R"RRRKR@( Rt node_inpsttermsRtscalarst non_scalarstnew_op_input_nb_elementst new_op_outputt new_op_inputRt mul_inputsR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_sum_prod_mul_by_scalarsL!   '+       3cC`st|jtjr|jjjdkr|jjtjkr|jd|jdkrtj |jd}t |j ||gSdS(s- Elemwise{sub}(X,X) -> zeros_like(X) iiiN( RRjR5RRtninR"R,RLR5RR(Rtres((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_elemwise_sub_zerossc`st|jtjsdS|jjjdkr2dS|jdj}t|jjtj tj fr|j d|j dkrtj |j dd|dt }t|j||gSt|jjtjtjfr*|j d|j dkr*tj|j dd|dt }t|j||gSt|jjtjtjfr|j d|j dkr|j d}t|j||gSt|jjtj r(|j djr(t|j djjtr(tj|j ddt dkr(tj |j dd|dt }t|j||gSt|jjtjr|j djrt|j djjtrtj|j ddt dkrtj|j dd|dt }t|j||gSt|jjtjr;|j djr;t|j djjtr;tj|j ddt dkr;|j dgSt|jjtjrtj|j ddt dkr|j djrt|j djjtr|j dgSt|jjtjrN|j djrNt|j djjtrNtj|j ddt dkrNtj |j dd|dt }t|j||gSt|jjtjrtj|j ddt dkr|j djrt|j djjtrtj |j dd|dt }t|j||gSt|jjtj r|j djrt|j djjtrt|j djjjtjrtg|j djj D]$}t|jo|jjt^qjrtj|j ddt dkrtj |j dd|dt }t|j||gSt|jjtjr|j djrt|j djjtrt|j djjjtjrtg|j djj D]$}t|jo|jjt^qortj|j ddt dkrtj|j dd|dt }t|j||gSfdt|jjtjr|j djr|j djrybt|j ddt }tj |j dd|dt }|dkrt|j||gSWqtk rqXndS( s... :note: These cases appear in the graph generated by scan. These optimizations will make the graph easier to read. # Comparing to itself is constant Elemwise[{LT,GT}](X, X) -> Elemwise[zeros](X) Elemwise[{LE,GE}](X, X) -> Elemwise[ones](X) Elemwise[{minimum,maximum}](X, X) -> X # Comparing shape to 0 can be constant Elemwise[LT](X.shape[i], 0) -> Elemwise[zeros](X) Elemwise[GE](X.shape[i], 0) -> Elemwise[ones](X) Elemwise[maximum](X.shape[i], 0) -> X.shape[i] Elemwise[maximum](0, X.shape[i]) -> X.shape[i] Elemwise[minimum](X.shape[i], 0) -> 0 Elemwise[minimum](0, X.shape[i]) -> 0 # The shape can be replaced with sum of shapes Elemwise[LT](add([anything that is shapes]), 0) -> Elemwise[zeros](X) Elemwise[GE](add([anything that is shapes]), 0) -> Elemwise[ones](X) # Shapes are never negative # Needed by Reshape.infer_shape Elemwise[EQ](Subtensor(Shape(x)), -N) -> Elemwise[zeros](X) NiiiRXR RJc`st|jtjtfrtSt|jtrU|jdjrU|jdjSt|jtj rt fd|jdDSt|jt rt fd|jDSdS(s. Return True if values will be shapes, so >= 0ic3`s'|]}|jo|jVqdS(N(R(R;RP(t investigate(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys sic3`s'|]}|jo|jVqdS(N(R(R;RP(RP(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys sN( RRjR5R%R&RRRLRRRER(R(RP(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRPs"(RRjR5RRRMRRXR"tLTtGTRLR5RRRtGERtMinimumtMaximumRR&R1R6REtEQR/R2(RRXRNRtcst((RPs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt!local_useless_elemwise_comparisons !"!"! """"""""""">""">""   "   c`s%t|jtjtjjfr!|jjdkrXtt |j dj n|j d}|j r!|j jtj kr!|j j \}}tjjrBt|jtjrB|j rBt|j jtjrB|j jj}t}x:D]2}t||ks||dkrt}PqqW|rBtjdqBn|j rt|j jtjr|j j d}|j jj}g}g} xMD]E}|t|kr||dkr|j|q| j|qWg} xD| D]<} | j| tg|D]} | | krd^qqWt|dkrtfdt|D} x-t| dkr| ddkr| d=qbWtdt| Dr|}nOtj|jj| |}tjjrt|jtjrtjdnt|jtjrltj|d|}tj ||}t| dkrtj|d| }qnt|jtjjrtj|d|}|j}tj ||tjg|D]}|j|j |^q}t| dkrtj|d| }qn|gSqq!ndS( s sum(a / dimshuffle{...}(b), axis=l) -> sum(a, axis={...}) / b, if dimension l of the DimShuffle is 'x' or prod(a / dimshuffle{...}(b), axis=l) -> prod(a, axis={...}) / b ** a.shape[l], if dimension l of the DimShuffle is 'x' iRsWARNING: Your current code is fine, but Theano versions between rev. 3bd9b789f5e8 (2010-06-16) and cfc6322e5ad4 (2010-08-03) would have given an incorrect result. To disable this warning, set the Theano flag warn.sum_div_dimshuffle_bug to False.ic3`s3|])\}}|ks'|dkr|VqdS(RN((R;R9tax(R(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys s cs`s!|]\}}||kVqdS(N((R;R9R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pys sRN(!RRjR5RRIRCRRWRRRLR`RRRR]tsum_div_dimshuffle_bugRRRR>R?RRKRRRERTR^tprodRXR\R6(Rt node_inputt numeratort denominatorRtcompatible_dimsRYtdimshuffle_inputtdimshuffle_ordertincompatible_dimstreordered_incompatible_dimstic_axtc_axtoptimized_dimshuffle_ordertoptimized_dimshuffletop_on_compatible_dimsRgRX((Rs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_sum_prod_div_dimshuffles!      "    .          - cC`st|jtjs-t|jtjjrt|jtjrKtjn tjj}|jjdkrmdSt|jjtt |j dj j kr|ddd|jj |j dgSndS(sA Sum{0,1,...N} -> Sum{} or Prod{0,1,...N} -> Prod{} NiRRX(RRjR5RRIRCRRWRnRRLRTR`RX(Rtopt_type((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_sum_prod_all_to_none7s -*1c C`st|jtjjs-t|jtjrt|jtjrKtjn tjj}|j\}|jj}t|j dkr|j rt|j j|jj r|j jj dks|jj dkr|dd||j jdgStt|j jj }xl|jj D]^}|}x0|j jj D]}||kr6|d7}q6q6W||kskt|j|qWt|tt|j jj t|jj ksttt|j jdjj}gt|D]'\}} ||j jj kr| ^q}gt|D]$\}} ||jj kr"| ^q"}gt|j jdjjD]}||kri|^qi} tjjjr|| krt|t| krtjdn||d|} | |j jdgSqndS(sN Prod(Prod()) -> single Prod() or Sum(Sum()) -> single Sum() iRXisWARNING (YOUR CURRENT CODE IS FINE): Theano versions between version 9923a40c7b7a and August 2nd, 2010 generated bugged code in this case. This happens when there are two consecutive sums in the graph and the intermediate sum is not used elsewhere in the code. Some safeguard removed some bad code, but not in all cases. You are in one such case. To disable this warning (that you can safely ignore since this bug has been fixed) set the theano flag `warn.sum_sum_bug` to False.N(RRjR5RIRCRRLRXR>RRRRRWRRZRaRKRRTR`RRRoRR]t sum_sum_bugR( RRjRDR/tnewaxisR9RRtalldimsRt newaxis_oldtcombined((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_op_of_opIsF -*   ' "   cC`s{t|jtjrw|jdjrwt|jdjjtjrw|jdj}tj|jddtdkrzdSt|jj t j t j frt |jdkrdSn>t|jj t jt jfsdSt |jdkrdSg}x|jdD]p}|j}|s"dSt|jt sa|jjd tt|jdjkredS|j|jdq Wt|jj |}|j|jdjkrdS|jj}|dkrtt|jdj}nt |dksd|kr*tjjjr&t jdndSy1t!|jddt}||dkrZdSWnt"k rodSX|gSdS( sL Reduce{scalar.op}(Join(axis=0, a, b), axis=0) -> Elemwise{scalar.op}(a, b) Notes ----- Supported scalar.op are Maximum, Mimimum in some cases and Add and Mul in all cases. Currently we must reduce on axis 0. It is probably extensible to the case where we join and reduce on the same set of axis. iRJNiiiRsYour current code is fine, but Theano versions prior to 0.7 (or this development version Sept 2014) might have given an incorrect result for this code. To disable this warning, set the Theano flag warn.reduce_join to False. The problem was an optimization, that modified the pattern "Reduce{scalar.op}(Join(axis=0, a, b), axis=0)", did not check the reduction axis. So if the reduction axis was not 0, you got a wrong answer.(R(#RRjR5tCAReduceRLRRR1RRR"RURTR>R6RRRRZRR`RKRRXRRRWRRoRR]t reduce_jointwarningsR/R2(RRCR RR t reduce_axist join_axis((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_reduce_joinsT"!!        tlocal_cut_useless_reducecC`sHt|jtjrD|j\}|j|jdjkrD|gSndS(sSum(a, axis=[]) -> a iN(RRjR5RrRLRTR(Rtsummed((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_reduces c C`st|jtjr|j\}|jdj}|jjdkrkt |j r|j j |gSqt |jj}g|D]}|j |r|^q}|rg}g}d}xYt|jD]H} | |kr| |kr|j|n|j| |d7}qqW|j |} |rt|jtjjjkrk|jj|jjd|} n|jjd|} | | gS| j |gSqndS(s/Remove reduction over broadcastable dimensions.iiRN(RRjR5RrRLRRXRRWRER^RR6RRR`RKRTRoRRIRR( RtreducedtodtypeRRtcuttableRQtpatternRtpt new_reducedR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_reduce_broadcastables4 &     cC`st|jtjs-t|jtjjr|j\}|jrt|jjtjr|jjd}|jjd}|jj dks|jj t t |j kr]yt|dt}|jdksttj|jt|j}t|jtjr'|jdd|}n|jdd|}|gSWqtk rYqXqyt|dt}|jdkst|jdd}gtt|D]"}||jj kr||^q}|r+tj|jt|j}t|jtjr||9}q+||}ntj|gtt|D]"}||jj krG||^qGgSWqtk rqXqndS(s sum(alloc(constant,shapes...)) => constant*prod(shapes) or prod(alloc(constant,shapes...)) => constant**prod(shapes) iiRJN(RRjR5RRIRCRLRR.RRWRZRR`R/RR"RaRR6RbRXtreshapeR2RR>R](RRDRtshapesRltcastedR9tto_prod((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_opt_allocsF - !!  !    "!   * cC`s]|jtjkrY|jdjrY|jdjjtjkrY|jdjjdgSndS(Ni(RjR5R@RLR(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt local_neg_negLs,cC`s|jtjkr|jdjr|jdjjtjkr|jd}|jj\}}|jr|jjtjkrt|jdkr |jjd}tj||gSqtj |j rt |t rt|jdkr |j }tj||gSqqndS(sf - (-a / b) -> a / b Also performs - (c / b) -> ((-c) / b) when c is a scalar constant. iiN(RjR5R@RLRRR>RR(RER^RRR(RtfracR)tdenomtnew_num((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_neg_div_negVs , ! cC`s|jtjkr|jdj}xi|jD][}yt|}Wntk rXq,nX|dkr,tt j dd|j |jSq,WndS(sX As part of canonicalization, we replace multiplication by zero with zero. iRXN( RjR5RRRTRLR/R2R:RoR#RX(RR R9Rc((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_mul_zerons  cC`s|jtjkrtjtj|jddkr|jd}tj tj |jdg}|j |j krtj |d|j }n|j |j krt|||j}n|gStSdS(Nig?iRX(RjR5RR(RER?R"RLRtinvRRXRYRTRhReR?(RR%R7((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_div_to_invs  cC`s4|jtjkr,tj|jddgStSdS(Nig(RjR5RtpowRLR?(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_inv_canonscC`s|jtjkrtj|jd}|dkrQtd|jd|jgS|dkrt|jd|jd|jgSnt SdS(Nii( RjR5RR?R"RLRhRReR?(RRW((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_pow_canonicalizes  'cC`sb|jtjkr^t|jdkr^|jd|jdkr[tj|jdgSq^ndS(sw x*x -> sqr(x) This is faster on the GPU when memory fetching is a big part of the computation time. iiiN(RjR5RR>RLR(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_mul_to_sqrs cC`su|jtjgkrqt|jdtjrqtj|jdjdkrq|jdj |j dj gSndS(sx // 1 -> x iiN( RjR5RRRLRR(RERcR6RRX(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_intdiv_by_onescC`st|jtjrt|jjtjjtjjfrt j |j ddkrt d|j d|j}t|j_|gSndS(s0 / x -> 0 iN(RRjR5RRRoR"tIntDivtTrueDivR?R"RLRhRReR(RR(RR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_zero_divs $ cC`s|jtjkr|jdj}|jd}|jd}tj|}|dk rt |j j |j j rd}t j |dkrtj|g}nt j |dkr|g}nt j |dkrtj|t jdd|g}nt j |dkr)tj|g}nt j |dkr\tjtj|g}nt j |dkrtj|g}nt j |dkrtjtj|g}n|rtj|d||d<|dj |jdj ks t||jf|SqntSdS( NiiiRXg?gii(RjR5RRRXRLR?R"RWRDRTR^R(RERR6tasarraytsqrtRRYRaR?(RR|txsymtysymRRg((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_pow_specializes:     '  c C`s|jtjkr|jdj}|jd}|jd}tj|}t|t j r|j dksrt y|d}Wqt k rqXn|dk rt|jj|jjrd}t|tt|krlt|dkrl|g}tjj|jg}t|}xZttt j|D]=} |jtj|| |jtjj|| q@Wd} d} xl|dkrtt j|} | r| || 9} | || 9} n|| } || } |d| 8}qWt|dkr?ttjj|dg| gj|} n|dkr`tj| g}ql| g}n|rtj|d||d<|dj|jdjkst ||jf|SqndS(sU This optimization is not the same on all device. We do it only on cpu here. iiiiN( RjR5RRRXRLR?R"RR(R`R"RaRRWRDRTR^tabsR^RoR"tget_scalar_typeRtlog2RKRRt CompositeR!RRY( RR|RRRRgtpow2t pow2_scalty_to_doR9trval1t rval1_scalt log_to_do((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_pow_specialize_devicesX      0  "!   %   c C`s>|jtjkr:t}g}d}d}x|jD]}xF|jr|jjtjkr|tN}|jjd}|d7}q=Wtj |}|dkr|d7}q4|dkr|d7}|tN}q4|dkrt d|j d|j gS|j |q4W||jkr:|rt|dkrq|rd|djtjdgkrVdS|d }q|d}nf|r|dkr|dkrdS|rtjdd |j dj}|g|}ntj|}t ||j d|j gS|rt d|j d|j gSt d|j d|j gSq:ndS( s& Remove special-case constants from mul arguments and useless neg in inputs. mul(-1, x) -> neg(x) mul(1, x, y) -> mul(x, y) mul(0, ...) -> alloc(0, shapes...) This is not done if we would add more nodes in the graph, like with: mul(-1, x, y) -/-> neg(mul(x, y)) iig?ggtboolNiRX(RjR5RR?RLRR@RR?R"RhRReRKR>RXt uint_dtypesR(R( RR@Rt nb_neg_nodetnb_cstRRRgtm1((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_mul_specializeBsN!          c `sfd}jtjkrg}xcjD]X}yt|}Wntk r`|}nXtj|dkr|q1n|j|q1Wt |t jkrj dj j }t |dkr+j dj j }tjtjd|d|}|j jtf|ks!t||St |dkrP||d}n|tj|}|dj |krtj|d|g}n|SntSdS(Nc`st|j}|S(N(R:RL(RPR%(R(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt fill_chainsgiiRX(i(RjR5RoRLR/R2R(RERKR>RRTRXR`RRR^RRaRYR?( RRRRRRXR`RWR ((Rs1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_add_specializes2  " tapply_all_optstmul_canonizer_groupscC`sxt|D]}|jr |jjtjkr |jjd|kr |jjdjjjdriq|j ||j |jjd|j tj |jjdq q W||fS(sConvert x/abs(x) into sign(x). itcomplex( RRRjR5tabs_RLRTRXt startswithRRKtsgn(t numeratorst denominatorstden((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytcheck_for_x_over_absXs 't X_over_absXcC`s|jtjkr|jdjr|jdks7t|jdjjtjkrtjg|jdjjD]}tj|^qmgS|jdjjtjkr|jdjj}tjtj|dtj|dgSndS(sn Move the abs toward the input. This is needed for check_for_x_over_absX to apply in more case. iiN( RjR5RRLRRMRaRR(RR9((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_abs_lifts "9cC`s|jtjkr!tg|jD]$}|jr|jjtjk^qdkr!g}x|jD]}|jr|jjtjkr|j|jjdqbt|t ryt |dt }Wnt k rt SX|dkjst S|j|qbt SqbWtjtj|gS|jtjkrtg|jD]$}|jr@|jjtjk^q@dkrtjtj|jdjjd|jdjjdgSdS(s] Merge abs generated by local_abs_lift when the canonizer don't need it anymore iiRJiN(RjR5RRRLRRRKRRR/RR2R?RER(RR9RLR"((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRUs*%-   : cC`s|jtjkr|j\}|jr|jjtjkrt|jjdt\}}}|rtj tj |dr|rt |dkrtj|}n |d}|j |j j kr|j|jdj }nttj||Sqq|jr|jjtjkrtj|jjddt}|dkrLdS|jjd}|j |j kr|j|j }ntjtj|gSndS(NRJii(RjR5tlogRLRRoRQRR(tallcloseRR>RXRTR6RR:tlog1pR,R1R@(Rtlog_argRFt scalar_inputsROtninpR=R9((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt local_log1p s, !   cC`s |jtjkr|jd}|jr|jjtjkr|jj}t|dkr_dSg|D]4}|jrf|jjtjkrf|jjd^qf}t|t|krtj|}|tj tjtjg|D]}||^q}t |j _ |gSqndS(Nii( RjR5RRLRRoR>texpRbRR'RR(RRtziRtpre_exptmax_preRR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt local_log_add+s    4$ c C`sY|jtjkrdS|jdj}|r]t|jtjr]|j}|jdj}nd}| st|jtj rdS|jdj|jj }}| st|jt ot|jj t j  rdS|jd}tj|d|}tj|||}|tjtjtj||d|}|rR||}n|gS(NiR(RjR5RRLRRRRWRRRRR"Rtmaxt makeKeepDimsRR( Rtsum_nodet dimshuffle_optexp_nodeRRt max_pre_exptmax_pre_exp_keepdimsR ((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_log_sum_expLs,  ,Rtignore_newtreesg?cC`s|dkrd}ntjdd|j}ttj||ttj||}|r~tj|dkrtgS|gSn|S(NgiRX(RWRoR#RXRR(RoRE(R)RRR#tzeroRP((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyt add_calculatews  ( tadd_canonizer_grouptlocal_add_canonizercC`s:d}t||t|}ttjtjg|D]#\}} ||| ||f^q6} ttjtjg|D]#\}} ||| ||f^q{} xgt||| | D]N\\}} \} } |t||t| t| |t| 7}qW||kr-t||fSt| | fS(Ng?( R>Rt itertoolststarmapR?R&RAR?R(t pos_pairst neg_pairsR)RR#tminscoretdiv_costtscoreRRt new_pos_pairst new_neg_pairstnntdd((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytdistribute_greedys 33 :  c C`stj|\}}t|dkr>| r>t|||fStttj|}tttj|}t}xTt|D]F} t||| gg|\} }}| rt}|j | qqWxTt|D]F} t||g| g|\} }}| rt}|j | qqW|s8||||fS|tj tt j tj |tt j tj |||fSdS(Ni( RRR>R?RRR?RRRRRR( tfactorR)RR#RHR@RRtchangeRtsuccessR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytattempt_distributions2  c C`s|jd}tj|\}}t|dkr?| r?tSgg}}t}|j}xkt|D]]}||krqhn|j|t||||\} }}}|| O}|j |qhWxkt|D]]}||krqn|j|t||||\} }}}|| O}|j |qW|sAtS||7}||7}tj ||} | j|jks}tS| gS(s' Optimize by reducing the number of multiplications and/or divisions. This optimization tries to apply distributivity of multiplication to addition in order to reduce the number of multiplications and/or divisions that must be done. The algorithm weighs division more than multiplication to account for the former's slightly greater computational cost. The following expressions are simplified: 1. ((a/x + b/y) * x * y) --> a*y + b*x 2. ((a/x + b) * x) --> a + b*x 3. There are other forms too where node is a true_div. The following expressions are not simplified: 4. ((a + b) * x) -/-> a*x + b*x This optimization aims to reduce computational cost. It may also increase numerical stability, e.g. when x and/or y tend to 0 in example 1. ii( RR?RR>R?RTRRRRKR( RR%R)RRt new_denumRR#t candidatet_changeRg((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_greedy_distributors>           c C`sx$|jD]}t|ts tSq W|jj|s=tStg|jD]}||jgf^qJ}tg|jD]}|tgf^qx}x+|j D] }dg||R@RRRRR/RR2RZRR RRYRR(R RXRYR)R(RRterfc_xRRRR0RR@RRtmul_negRKR9ttmptcst2RWttrue_div_no_mulR R R ((R!s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR "s- -             C%   cC`sdS(Ni ((R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR]sc`s:dkrfdnfdS(s We parametrize it to make it work for Elemwise and GpuElemwise op. Parameters ---------- OP GpuElemwise or Elemwise class (the one that we want to fuse) max_input_fct A function that returns the maximum number of inputs that this elemwise can take (useful for GpuElemwise). GPU kernel currently has a limit of 256 bytes for the size of all parameters passed to it. As currently we pass many information only by parameter, we must limit how many ops we fuse together to avoid busting that 256 limit. On the CPU we limit to 32 input variables since that is the maximum numpy support. c`s |S(N((RR(Rl(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytmakertsc`st|jk rtSt|jdkr2dSg}g}g}|}t|j}t}x|jD]}t}t} g} g} |jrt|jjrttg|j D]\} } | ^qdkr|jjdj |jdj krt }yg}x|jjD]}||krM|j ||j |q|| krv|j | | j |qtj|jj}yJtjj|}|jdkr|jd|j_n ||j_Wntk rnX|j || j || j |dqW|jjjdt |}|jjjj|djdg|jjD] }d^q_g|jjD] }d^q{iWn-tk rt } ntk rt } nX| rtjd t|jjjt}qn|t| d}x*| D]"}||jkr|d8}qqW|r}||kr}t }|}|j | |j | |j |qo|j!||jj!|kr||j |}ntj|jj}ySt"j#j$d krtjj|}|jdkr|jd|j_qnWntk r2nX|j ||j ||j |qoW|shtS|t|kst|t|krt%d n|jjdt |}yT|djjj|djdg|D] }d^qg|D] }d^qiWnetk rBtjd t|djjtStk rttjd t|djjtSXtj&||}|||j} t| jdkst'|jdj| jdjkst't| j|krtjd tSxxt r| }|tk r||dk r|t|t| jksTt't|dkslt'|dj} q Pq W| jS( s% As part of specialization, we fuse two consecutive elemwise Ops of the same shape. For mixed dtype, we let the Composite op do the cast. It lets the C compiler do the cast. The number of dimensions is validated at call time by theano itself. iNiiRttest_presence_of_c_codeRRss%s does not implement the c_code function. As well as being potentially slow, this disables loop fusion of this op.toffsSomething has gone wrong with the elemwise fusion optimization. We skip this optimization. You can ignore this message, your code will run correctly, but may be slower.sAloop fusion failed because Op would exceed kernel argument limit.()RTRjR?R>RRLRRRnRR^RRKRR"RRXt make_variableRtget_test_valueR"tflattenRt test_valueRHRR1RRVRtinfoRbRtcountRoRtcompute_test_valueRRRaRW(RRLts_inputsts_gt max_nb_inputt new_nb_inputtfusedR9t do_fusiontcatcht tmp_inputt tmp_scalarRR0t tmp_s_inputRRttvts_opRRt new_nb_input_RRPt s_new_outtCR (Rlt local_fuseRt max_input_fct(s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR,ws"  4                !    * !    &   !N(RW(RlR-R((RlR,RR-s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_elemwise_fusion_op]s cC`stjjsdSdS(Nii(RoRtcxx(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytelemwise_max_input_fctQs tFusionOptimizercB`s;eZdZdZdZdZeddZRS(s2Graph optimizer for Fusion of elemwise operations.cC`stj|||_dS(N(R*Rmt optimizer(RkR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRm_s cC`s|jtjdS(N(RnR-tReplaceValidate(RkRe((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRrcscC`st}d}d}d}d}|jrN|jj}|jj}|j} nx|r_tj} t|j} |tj| 7}| j t }x| D]} | |j kr|j | } | rNt | t | jksty?|jtt| j| d|jjt}|d7}WqKtk rG|d7}qKXqNqqW|d7}qQW|jr|jj|}|j| }i}x]t|jD]7\}}||kr|||||RRatreplace_all_validateRARRR RRW(RkRet did_somethingtnb_itertnb_replacementtnb_inconsistency_replacet time_toposorttvalidate_beforetcallbacks_beforetcallback_beforett0tnodelistRRR5t callback_timetcallbacks_timeRRP((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRfsZ       !        icC`s=d|}t|dd|t|d|dd|t|d|dd|t|d|d d|t|d |d d|t|d |d d||d dkrt|dd|xZtt|ddddddD])}|ddkrt|d|qqWnt|d|dd|dS(Ns R1Rss nb_iteris nb_replacementis nb_inconsistency_replaceis validate_timeis callback_timeis callbacks_timeitkeycS`s|dS(Ni((R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRsiis s time_toposorti(RyRzR(R|R}R~RR9((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRs 3(RRRRmRrRRR(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyR1]s    3c C`st|jt s5t|jjtjtjf r9tS|jjj}g}t}t |j }t d}t |jdr|jj |}nx|j D]}|jr-t|jjtr-t|jjj|r-t |jdkr-|t |jj d|kr-|j|jj t}q|j|qW|r|j|}t|jd||jrt|j}|r|Sn|gSdS(s<Fuse consecutive add or mul in one such node with more inputs. It is better to fuse add/mul that way then in a Composite node as this make the inner graph of the Composite smaller. This allow to put more computation in a Composite before hitting the max recusion limit when pickling Composite. tinft max_inputsiiN(RRjRRR"R6RR?RR>RLR]RZRIRRRRRKRRtlocal_add_mul_fusion( RR(R R!t nb_inputsRIRRtoutput2((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pyRJs6 "     s1enabling optimization fusion elemwise in fast_runRJtfusiontcomposite_elemwise_fusiontelemwise_fusioni1tlocal_elemwise_fusions5not enabling optimization fusion elemwise in fast_runcC`st|jt s,t|jjtj r0dS|jj}gt|jD]\}}|jrL|^qL}t |t |jkrg|D]}|j|^q}tjd|j d|}td|dt |j }t t g|D]}|j|^q|SdS(sbFor elemwise Composite that have multiple outputs, remove the outputs that are not used. NRLRRR(RRjRRR"RRRRR>RLRRRA(RtcompR9to_externR0RRR((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_useless_composites   tremove_consider_constanttremove_zero_gradtremove_disconnected_gradcC`s#t|jtjjr|jSdS(N(RRjRotgradienttGradClipRL(R((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytlocal_grad_clipsc C`sDt|jtjstS|jdj sJt|jdjjtj rNtS|j}|jdjj}|d}|d}|ddd}|ddd}d}xt||D]o\}} || krt|tr|j dkrqt d| tj | ||d|RR?R@RBRCRLRORXRiRkRqRrtAlltAnytProdWithoutZerost ALL_REDUCERwRzRRRRRRRRRRRRRRRRt LocalOptGroupt mul_canonizerRRRRRURRRRRR,Rt add_canonizerRRRRXRRRt PatternSubterfRRRRRRRRRRRRR R R.R0RPR1RJRtdebugt SequenceDBt fuse_seqoptRSRWtconsider_constant_t zero_grad_tdisconnected_grad_RXRYRb(((s1/tmp/pip-build-X4mzal/theano/theano/tensor/opt.pytsd         "L.    '  $3  .#  $ $e v     , $)       $*'4  $!!!. 'T '`!$$# T !G$3$$$~ f !M$E$:!J   !   !        !!!3 !m'$7 %''4')''  'V$Q'F!','$! !'W!-$Q! *X!*-{**DO   !&*2! !    !! * $ !CL (    !'$ $&     !0D(                                                                 $'$:   M .                 $