Xc@`sdZddlmZmZmZddlmZmZddlmZddlZddl Z ddl Z ddl Z ddl mZddlmZddlmZdd lmZdd lmZdd lmZd d lmZejZejdZdZee_ddddZde fdYZ!de fdYZ"ddZ#dde$dZ%de!fdYZ&dZ'de&fdYZ(dZ)de!fdYZ*dZ+dS( s WRITEME i(tabsolute_importtprint_functiontdivision(tcopytdeepcopy(t getsizeofN(tizip(treraise(tStringIO(tutils(tgraph(tTypei(tundefc`sfd}t|dr|j}|d|d kr^|d|d|dq|r|dx!tj|D]}||q~W|dqnd S( s\ Log Theano's diagnostic stack trace for an exception raised by raise_with_op. c`std|jddS(Nslog_thunk_trace: %stfile(tprinttstrip(tmsg(tf(s//tmp/pip-build-X4mzal/theano/theano/gof/link.pytwrite!st__thunk_trace__s$There was a problem executing an Op.s)Could not find where this Op was defined.sO * You might have instantiated this Op directly instead of using a constructor.sS * The Op you constructed might have been optimized. Try turning off optimizations.sDefinition in: sNFor the full definition stack trace set the Theano flags traceback.limit to -1N(thasattrRtNonet tracebackt format_list(tvalueRRttrace2tline((Rs//tmp/pip-build-X4mzal/theano/theano/gof/link.pytlog_thunk_traces       cC`st|t|||dS(s6 This function is meant to replace excepthook and do some special work if the exception value has a __thunk_trace__ field. In that case, it retrieves the field, which should contain a trace as returned by L{traceback.extract_stack}, and prints it out on L{stderr}. The normal excepthook is then called. Parameters: ---------- type Exception class value Exception instance trace Traceback object Notes ----- This hook replaced by nosetests, so it does not run in nose tests. N(Rt __excepthook(ttypeRttrace((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt thunk_hook5s c* C`s |d>krtj}n|\}}}|tkrIt|||ny|jdjj}Wn>tk ry|j jj}Wqtk rd?}qXnX||_ ||_ |j j }||kr|j|} nd>} | |_g} dt|} |jd>k r%| d| 7} ng|jD]} t| dd^q/} | d| 7} |d>k r)t|dr(g|jD]} t| ddd ^q}g|jD]} t| dd d ^q}g}xc|jD]C} t| dd d dkr|j| dq|jdqWnd}d}d}g|jD]&}g|jD]}|d^qT^qD}| d|d|d|7} tjjdkr| dtg|jD](}tt|ddddd^q7} nt|j dr| dt|j j7} n| d|7} n | jdt|jdjdg}t|trt|dkr| d 7} t}x|D]}tj||qW| t|j 7} n | jd!tjjdkr't}tj!j"|d"|d#t#d$t#| d%7} | |j 7} ntjjdkrU |d>k rU | d&7} g|j jD]!}t|tj$j%r\|^q\}g|j jD]!}t|tj$j%s|^q}g}d}d}x7|D]/}g} | jt|d>}!t||ddrR||dj&}!t|!dkr?| j|!q_| jt'n | jd>t||ddr||dj(}"| jt)j(|"j*|!d>kr| jd qt)j(|"j*t)j+|!}#| j|#||#7}|j,s||#7}qt|j,j d'd>r|j,j j-}$|j,jj|}%||d}&|%|$krt|$|%d(kszt.||j,j|$|%dd}'|j/j0|&|'r||#8}qqnt|j,j d)d>r|j,j j1}$|j,jj|}%||d}&|%|$kr|t|$|%d(ks4t.||j,j|$|%dd}'|j/j0|&|'ry||#8}qyq|qn.t2||d}(| j|(| jd ||kr| jt#n)||kr| jt3n | jd>|j| qWdd*l4m5})|j6d+|)d,d-t#x|D]}|d,d krRq6n| d.|dd/7} |d0t#kr| d17} n|d0t3kr| d27} n|d(d>k r| d3t|d(7} n| d4|d57} |d,d>k r | d6|d,7} q6| d77} q6W| d8||d9d:d:f7} | d;||d9d:d:f7} n | jd<y+|t|| d7d7j7| }Wn%t8k r t9d=t|nXt|||d>S(@s Re-raise an exception while annotating the exception object with debug info. Parameters ---------- node : Apply node The Apply node object that resulted in the raised exception. exc_info : tuple, optional A tuple containing the exception type, exception object and associated traceback, as would be returned by a call to `sys.exc_info()` (which is done if `None` is passed). storage_map: dict, optional storage map of the theano function that resulted in the raised exception. Notes ----- This re-raises the exception described by `exc_info` (or the last one raised, if `exc_info` is omitted) and annotates the exception object with several new members which may be helpful for debugging Theano graphs. They are: * __op_instance__: The Op that is responsible for the exception being raised. * __thunk_trace__: A traceback corresponding to the code that actually generated the exception, if it is available. * __applynode_index__: The index of the Apply node corresponding to this op in `op.fgraph.toposort()`. The exception is not annotated if it is of type `KeyboardInterrupt`. is# Apply node that caused the error: s Toposort index: %dRsNo types Inputs types: %s tinputstshapes No shapeststridess No stridestsizeiis not showns*The thunk don't have an inputs attributes.s/So we can't access the strides of inputs valuess'And can't print its inputs scalar valuesInputs shapes: %ss Inputs strides: %ss Inputs values: %sthighs Inputs type_num: %stdtypettnumt__input_name__s Inputs name: %s s Outputs clients: %s sYHINT: Use another linker then the c linker to have the inputs shapes and strides printed.RsZ Backtrace when the node is created(use Theano flag traceback.limit=N to make it longer): sHINT: Re-running with most Theano optimization disabled could give you a back-trace of when this node was created. This can be done with by setting the Theano flag 'optimizer=fast_compile'. If that does not work, Theano optimizations can be disabled with 'optimizer=None'.R t stop_on_namet print_types Debugprint of the apply node: s Storage map footprint: tview_mapit destroy_map(t itemgettertkeyitreverses - s, isShared Input, sInput, s Shape: %s, sElemSize: %s Byte(s)is, TotalSize: %s Byte(s) s s TotalSize: %s Byte(s) %.3f GB g@is& TotalSize inputs: %s Byte(s) %.3f GB ssHINT: Use the Theano flag 'exception_verbosity=high' for a debugprint and storage map footprint of this apply node.s>WARNING: %s error does not allow us to add extra error messageN((:Rtsystexc_infotKeyboardInterruptRtoutputsttagRtAttributeErrortopRt__op_instance__tfgraphttoposorttindext__applynode_index__tstrR tgetattrRtappendtclientsttheanotconfigtexception_verbosityR(t isinstancetlisttlenRRt print_listtgetvaluetprintingt debugprinttTruetcompiletSharedVariableR!ttupleR%tnptitemsizetprodtownerR+tAssertionErrorRtmay_share_memoryR,RtFalsetoperatorR-tsorttjoint TypeErrorR(*tnodetthunkR1t storage_maptexc_typet exc_valuet exc_traceRttopot node_indexthintstdetailed_err_msgtiptttypestshapesR"t scalar_valuestvartcR?tittrtsiotsubtrRtitemtshared_input_listtnonshared_input_listtstorage_map_listt total_sizettotal_size_inputstktstorage_map_itemt shapeinfoR%tsztvmaptout_idxtdatat input_datatbytesR-((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt raise_with_opTs4"        ( ))6  @!      !!                 ( tLinkercB`s8eZdZedZdZedZdZRS(s WRITEME cC`s(t|}|tk r$||_n|S(N(RR tallow_gc(tselfR~tnew((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pytcloneNs   cC`s%tjdt||jjdS(s This function must return a triplet (function, input_variables, output_variables) where function is a thunk that operates on the returned variables. If inplace is True, the input_variables and output_variables lists will be the same as the inputs and outputs of the graph provided to the L{Linker}. Else, independent variables will be returned. Examples -------- x, y = Variable(Double), Variable(Double) e = x + y fgraph = FunctionGraph([x, y], [e]) fn, (new_x, new_y), (new_e, ) = MyLinker(fgraph).make_thunk(inplace) new_x.data = 1.0 new_y.data = 2.0 fn() print new_e.data # 3.0 print e.data # 3.0 iff inplace == True (else unknown) t make_thunkN(R tMethodNotDefinedRt __class__t__name__(R((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRTsc `sO|j|\fd}|_|_|_|S(s Returns a function that takes values corresponding to the inputs of the fgraph used by this L{Linker} and returns values corresponding the the outputs of that fgraph. If inplace is True, the calculations will operate in the same storage the fgraph uses, else independent storage will be allocated for the function. Example ------- e = x + y fgraph = FunctionGraph([x, y], [e]) fn = MyLinker(fgraph).make_function(inplace) print fn(1.0, 2.0) # 3.0 print e.data # 3.0 iff inplace == True (else unknown) If unpack_single is True (default) and that the function has only one output, then that output will be returned. Else, a list or tuple of length 1 will be returned. c`sd}t|tkrEt|tt|nx&t|D]\}}||_qUWrtjgD]}|j^qSgD]}|j^qSdS(NcS`s!d|ddg|dk|fS(Ns,Function call takes exactly %i %s (%i given)targumentt argumentsi((ttakestgot((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyte_aritys(RERXRRyR tto_return_values(targsRtargtvariable(R R3RZt unpack_single(s//tmp/pip-build-X4mzal/theano/theano/gof/link.pytexecutes $  (RRZR R3(RRtkwargsR((R R3RZRs//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt make_functionns    cC`s |jS(N(R9(RR8((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pytschedules( Rt __module__t__doc__R RRRJRR(((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyR}Hs    +t ContainercB`sneZdZeedddZdZdZeeeZ eeeZ dZ dZ dZ RS(s This class joins a variable with its computed value. It is used in linkers, especially for the inputs and outputs of a Function. Parameters ---------- r : a Variable or a Type storage A list of length 1, whose element is the value for `r`. readonly : bool True indicates that this should not be setable by Function[r] = val. strict : bool If True, we don't allow type casting. allow_downcast If True (and `strict` is False), allow upcasting of type, but not downcasting. If False, prevent it. If None (default), allows only downcasting of float to floatX scalar. name : str A string (for pretty-printing?) cC`st|t s#t|dk r2tdnt|trM||_n |j|_|dkr}t|dd|_n ||_||_ ||_ ||_ ||_ dS(Nis-storage must be a list of length at least onetname( RCRDRERXR RRR=Rtstoragetreadonlytstricttallow_downcast(RtrRRRRR((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt__init__s#       cC`s |jdS(Ni(R(R((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt__get__scC`s |jrtd|jny|dkr?d|jd(R<R(R((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt__str__scC`sdt|jddS(NRiR(treprR(R((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt__repr__sc C`s>t|jd|k}t|t|jd|t|jd|t|jd|t|jd|t|jd|t|jd|}|jddk r:|jj |jd r:| st |jj |jdst |jj |jddt dt |jd<|jd|t|jd storage called the `storage_map`. This function also returns `input_storage`, which is a list of storages corresponding to fgraph.inputs. This function also returns `output_storage`, which is a list of storages corresponding to fgraph.outputs. sVGiven input_storage conflicts with storage in given storage_map. Given input_storage: sStorage in storage_map: sXGiven output_storage conflicts with storage in given storage_map. Given output_storage: N( RR RERRtzipR3RCR tConstantRyt setdefault( R8tordert input_storagetoutput_storageR[tinputRRRY((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt map_storages@+   "!  !    #c `sdkrgnttkrQtdttfnrttkrtdttfnfd}|}n<|rfd}|}nfd} | }|S(s WRITEME Parameters ---------- fgraph thunks The list of program instructions. order The list of apply instances that gave rise to the thunks (same order as thunks). post_thunk_old_storage A list (corresponding to thunks, order) whose elements are lists of storage cells, that should be cleared after running thecorresponding thunk. A value of None disables this functionality. no_recycling Storage elements that cannot be 'recycled' by repeatedly executing the program. These storage elements are cleared before re-running. nice_errors Run in such a way that the double-traceback is printed. This costs a bit of performance in the inner python loop. s%Length of thunks and order must matchs6Length of thunks and post_thunk_old_storage must matchc`sxD]}d|deZdZdddZdddZddddZRS(s Basic L{Linker} subclass that calls the perform method on each L{Op} in the L{FunctionGraph} in the order given by L{Linker.schedule}. cC`sC|dkrtjj}nd|_||_|r?||_ndS(N(RR@RAR~R8R(RR~R((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRs    cC`sn|dkrg}n|jdk rX|j|k rXt|d|jj|||S||_||_|S(s$ Parameters ---------- fgraph A PerformLinker can have accepted one FunctionGraph instance at a time. no_recycling WRITEME Returns ------- object self (TODO: WHY? Who calls this function?) R~N(RR8RR~tacceptR(RR8Rtprofile((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRs     cC`s|j}|j|}|j}t|||||\}}}i}x$|D]}|jdkg||RJRDtvaluesR t differenceRtadd_clear_storageR[RR(RRRR[R8RRt compute_mapRsRRYtvRRRRRRRR((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRsX  !   '+      ( ,   .1N(RRRRRRR(((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRsc`sfd}||_dS(Nc`s#xD]}d|d is the thunk returned by the n'th linker. (If you want to run the program, make sure to call the necessary thunks in this function.) Notes ----- The outputs of the first linker will be returned. This linker ensures that each linker has its own storage for inputs and outputs and intermediate variables. There is no interference between linkers. cC`sd|_||_||_dS(N(RR8tlinkerstwrapper(RRR((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRs  cC`s;|jdg|jD]}t|^qd|j}|S(s Shallow copy of a WrapLinker. Returns ------- object A copy of self, where each of the linkers in self.linkers have been shallow-copied. It is useful because in FunctionMaker, copy.copy is called on the Mode's linker, so that it is not modified inplace when linker.accept() is called. In this case, we want the wrapped linkers to be copied too. RR(RRRR(Rtltother((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyt__copy__s " cC`s;|jdg|jD]}|jd|^qd|jS(NRR~R(RRRR(RR~R((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRs (cC`s|dkrg}n|jdk rX|j|k rXt||j|jj||S||_||_g|jD]}|j||^qt|_|S(s Parameters ---------- fgraph : gof.FunctionGraph The fgraph which we will link. no_recycling : a list of Variables that belong to fgraph. If a Variable is in no_recycling, L{WrapLinker} will clear the output storage associated to it (for each linker in linkers) during the computation to avoid reusing it. N(RR8RRRRR(RR8RRtlinker((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRs    (cC`sdS(N((RRR Rt thunk_groups((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pytpresc `sj}jdj|g}|jdd|gjdD]}|j|^qC7}t|\}}}}|d} x-|dD]!} | | kstdqqWd|d} tt|gt|D]} | d^qgxqtD]`\} }xQt |j D]@\}}||kr/x%| D]}j |j |qNWq/q/WqWj j fd}|_|| fS(NiRisFAll linkers to WrapLinker should execute operations in the same order.c`sxLdD]@}x7t|D]&\}}t|jd|jdRRR(RRRRRtfnst output_listst thunk_listst order_listst order_list0t order_listtoutputs0RRRYtjRRZR((RRRRRRRRs//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRs2 -    #  #  $ N( RRRRRR RRRRR(((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRqs    c`sfd}t||S(sa Variant on WrapLinker that runs a series of wrapper functions instead of just one. c`sxD]}||qWdS(N((RR(twrappers(s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyRs (R(RRR((Rs//tmp/pip-build-X4mzal/theano/theano/gof/link.pytWrapLinkerManys(,Rt __future__RRRRRR0RRtnumpyRNR@t theano.compatRtsixRt six.movesRt theano.gofR R ttheano.gof.typeR R t excepthookRtstderrRRRR|tobjectR}RRRJRRRRRRR(((s//tmp/pip-build-X4mzal/theano/theano/gof/link.pyts<       Vg dG $|