BVhFdZddlZddlmZddlZddlmZddlmZddlm Z ddl m Z ddl m Z dd l mZdd lmZdd lmZdd lmZdd lmZddlmZddlmZ ddl mZdZdZdZdZdZdZdZ dZ!dZ"dZ#dZ$dZ%dZ&dZ'd Z(d!Z)d"Z*d#Z+d$Z,eriejZeej\ej^ej`ejbejdejfejhejjejlejnejpejrejtejvejxejzej|ej~ejejejejejejejejejeje jjej~e jjejne jjeje jjejre jjejfe jje e jje"e jje$e jje&e jje(e jje*e jje+e jje,i ZXnd%ZYd&ZZd'Z[d(Z\d)Z]d*Z^d+Z_d,Z`d-Zad.Zbd/Zcie jjee jje!e jje#ejZeej\eYej`eZejde[ejhe\ejle[ejpe[ejte^ejxe_ej|e[eje[eje`ejeaejebejece jje]e jje]e jje]e jje]e jje]e jje+e jje,iZXd0Zdd1Zed2Zfd3Zgd4Zheie jZe j\e j`e jde jle je j|e jhe je je je je je jte jxe je je je je je jgZjd5Zkd6Zld7ZmemejejfZpemejZremejZtemejZvemewZxd8Zyie jexe jete jete jZere j\ere j`ere jepe jdepe jhepe j|epe jele jele jele jele jele jeve jpepe jlepe jtepe jxepiZ{d9Z|d:Z}ed; dId<Z~ed=d>Zd?Zd@ZedAdJdBZdCZejGdDdEeZej ejefZedFdGZeZdHZy#e$rdZYwxYw)Kz!Utilities to create TensorProtos.N)Protocol) tensor_pb2)tensor_shape_pb2)pywrap_tf_session)dtypes) errors_impl) tensor_shape)core)internal)compat)nest) numpy_compat) tf_export)fast_tensor_utilTFctj|tjj tj j SN)r np_asarraynpfloat16viewuint16itemxs W/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/framework/tensor_util.pyExtractBitsFromFloat16r.s1  BJJ / 4 4RYY ? D D FFcr|jj|Dcgc] }t|c}ycc}wr)half_valextendr tensor_proto proto_valuesrs r#SlowAppendFloat16ArrayToTensorProtor$2s-*67Qa 774ctj|tj|tj j tjyNdtype)rAppendFloat16ArrayToTensorProtorrrrrrr"r#s r&_MediumAppendFloat16ArrayToTensorProtor,8s722l"**=BB299MOrctj|tjjj t jjSr') rrrbfloat16as_numpy_dtyperrrrrs rExtractBitsFromBFloat16r0?s8  v-- //3tBIIttvFrcr|jj|Dcgc] }t|c}ycc}wr)rr r0r!s r$SlowAppendBFloat16ArrayToTensorProtor2Ds-+78aq!88r%ctj|tj|tj j jtjyr') r AppendBFloat16ArrayToTensorProtorrrr.r/rrrr+s r$FastAppendBFloat16ArrayToTensorProtor5Js=33L++ foo<<>>Bd299oOrc|xjtj|tjj j tjjz c_yr') float8_valrrr float8_e5m2r/rruint8tobytesr+s r&SlowAppendFloat8e5m2ArrayToTensorProtor;PsG f00??A tBHH~wy rctj|tj|tj j jtjyr') rAppendFloat8ArrayToTensorProtorrrr8r/rrr9r+s r&FastAppendFloat8e5m2ArrayToTensorProtor>YsA11 f00??AAEbhhQrc|xjtj|tjj j tjjz c_yr') r7rrr float8_e4m3fnr/rrr9r:r+s r(SlowAppendFloat8e4m3fnArrayToTensorProtorA`sG f22AAC tBHH~wy rctj|tj|tj j jtjyr') rr=rrrr@r/rrr9r+s r(FastAppendFloat8e4m3fnArrayToTensorProtorCisE11 f22AACCG4hhDrc|xjtj|tjj j tjjz c_yr') r7rrrfloat8_e4m3fnuzr/rrr9r:r+s r*SlowAppendFloat8e4m3fnuzArrayToTensorProtorFqH f44CC tBHH~wy rctj|tj|tj j jtjyr') rr=rrrrEr/rrr9r+s r*FastAppendFloat8e4m3fnuzArrayToTensorProtorI{?11 f44CC RXX rc|xjtj|tjj j tjjz c_yr') r7rrrfloat8_e4m3b11fnuzr/rrr9r:r+s r-SlowAppendFloat8e4m3b11fnuzArrayToTensorProtorMsH f77FF tBHH~wy rctj|tj|tj j jtjyr') rr=rrrrLr/rrr9r+s r-FastAppendFloat8e4m3b11fnuzArrayToTensorProtorOs?11 f77FF RXX rc|xjtj|tjj j tjjz c_yr') r7rrrfloat8_e5m2fnuzr/rrr9r:r+s r*SlowAppendFloat8e5m2fnuzArrayToTensorProtorRrGrctj|tj|tj j jtjyr') rr=rrrrQr/rrr9r+s r*FastAppendFloat8e5m2fnuzArrayToTensorProtorTrJrctj|tjjj t j}|jj|jyr') rrrint4r/astyperint8int_valr tolistr!s r SlowAppendInt4ArrayToTensorProtor[sM&++4466c||jj|Dcgc]}|jc}ycc}wr)bool_valr rr!s r SlowAppendBoolArrayToTensorProtors*  L!Aq!&&(!AB!ArccF|jD]\}}||k(s |cSyr)items) dtype_dictr)keyvals rGetFromNumpyDTypeDictr1s/""$hc3 e| j rc|jtjk(s|jtjk(rtrt j StStt|Sr) typerbytes_str__FAST_TENSOR_UTIL_AVAILABLErAppendObjectArrayToTensorProtorr_NP_TO_APPEND_FNr(s rGetNumpyAppendFnr9sF  ZZ299 bgg 5"  < << // / 77rcT|jDcgc]}|jc}Scc}w)zConvert a TensorShape to a list. Args: shape: A TensorShapeProto. Returns: List of integers representing the dimensions of the tensor. )dimsize)shapers rTensorShapeProtoToListrFs $ii (s#(( (( (s%crt|ttfsgS|sdgSt|gt |dzS)z9Returns the inferred dense dimensions of a list of lists.r) isinstancelisttuplelen_GetDenseDimensions) list_of_listss rrrRs= MD%= 1 I  3J   "5mA6F"G GGrc#xKt|ttfr|D]}t|D]}|y|ywr)rrr_FlattenToStrings)nested_stringsinnerflattened_strings rrr\sFu ./6  s8:ct|r) ValueError)r{s r _check_failedrs 1 rct|ttfs t|t|tr|Dcgc] }t |}}y|Dcgc] }t |}}ycc}wcc}wr)rrrr _check_int_check_quantizedvaluesr{_s rrrsZ FT5M *& &'1A'A'&,- ! -A- (-s A$A)cfd}|S)Nctj|D]U}t|rt|tjr!t |j jrKt|Wyr) r flattenrrndarray issubclassr)rr)rr{expected_typess rrz)_generate_isinstance_check..innersM \\& !N+!RZZ(!'',,7a r)rrs` r_generate_isinstance_checkrs ,rctj|Dcgc]'}t|tjr t |)}}ycc}wr)r rrr Symbolrrs r_check_not_tensorrs?!%f!5&A Q $Q&!&&s,Ac |t}n t|} ||y#t$rU|jrt}n?|j rt }n,|jrt}n|jrt}nt}YgwxYw#t$rR}|j\}| tdtd|jd|dt|j dd}~wwxYw)Nz7Expected any non-tensor type, but got a tensor instead.z Expected , but got z of type 'z'.)r _TF_TO_IS_OKKeyError is_integerr is_floating _check_float is_complex_check_complex is_quantizedrrargs TypeErrornamer__name__)rr)fnemismatchs r_AssertCompatiblers ] B   b7vJ                     7JX } O PP  %**ZzBx.112"6 77 7s( A?AA<;A<? CA CCc(t|tjrt|tjsyt t |ddstt |ddt ry t|t|t S#t$rYywxYw)z&Check if a given object is array-like.F __array__N__array_interface__T) rr rValuecallablegetattrdict memoryviewbytesr)objs r_is_array_likers~T[[!*S$***E wsK./3T:DA &sO#u% %%  s) B BBmake_tensor_protoc b |r |r tdt|tjr|S|rt j |}|tj tjtjtjtjfv}t|rtj|}t|tjtj fr/|r)|j"r|j%|j&}n{|}nw| td|r|j"r |j&}nd}|@tj(|tj*dk(rtj,||}nvt/||tj0||}t3|j4t7|k7r3|s1td|dt7|dt3|j4d |j8tj:k(r"| |j%tj<}nV|j8tj*k(r9|7|j%tj>}tj@||r|}t j |j8} | tCd |j8d |r|} |DtE|d r|jF| jFk7rtCd |d |d|j8d ||j4}d} |jH} n|D cgc] } tK| }} tj(|tj*} | |jHk(} |r[|j4dk(s|j4tMk(rn|jH| k7rtCdtM|d|j4d |r=|j4tM|k7r%tCdtM|d|j4d |jH| kDrtd| dd|jHdd tj| jNtQjR|jU} | rK| tVvrC| dkDr>|jH|jXzdk\r td|j[| _.| S| tj^k(ret|tjsKta|} |Dcgc]}tcjd|}}| jfji|| S|jk}tm|j8}|tCd| jnd || || Scc} wcc}w#tB$rtCd|dwxYw)aCreate a TensorProto. In TensorFlow 2.0, representing tensors as protos should no longer be a common workflow. That said, this utility function is still useful for generating TF Serving request protos: ```python request = tensorflow_serving.apis.predict_pb2.PredictRequest() request.model_spec.name = "my_model" request.model_spec.signature_name = "serving_default" request.inputs["images"].CopyFrom(tf.make_tensor_proto(X_new)) ``` `make_tensor_proto` accepts "values" of a python scalar, a python list, a numpy ndarray, or a numpy scalar. If "values" is a python scalar or a python list, make_tensor_proto first convert it to numpy ndarray. If dtype is None, the conversion tries its best to infer the right numpy data type. Otherwise, the resulting numpy array has a compatible data type with the given dtype. In either case above, the numpy ndarray (either the caller provided or the auto-converted) must have the compatible type with dtype. `make_tensor_proto` then converts the numpy array to a tensor proto. If "shape" is None, the resulting tensor proto represents the numpy array precisely. Otherwise, "shape" specifies the tensor's shape and the numpy array can not have more elements than what "shape" specifies. Args: values: Values to put in the TensorProto. dtype: Optional tensor_pb2 DataType value. shape: List of integers representing the dimensions of tensor. verify_shape: Boolean that enables verification of a shape of values. allow_broadcast: Boolean that enables allowing scalars and 1 length vector broadcasting. Cannot be true when verify_shape is true. Returns: A `TensorProto`. Depending on the type, it may contain data in the "tensor_content" attribute, which is not directly useful to Python programs. To access the values you should convert the proto back to a numpy ndarray with `tf.make_ndarray(proto)`. If `values` is a `TensorProto`, it is immediately returned; `dtype` and `shape` are ignored. Raises: TypeError: if unsupported types are provided. ValueError: if arguments have inappropriate values or if verify_shape is True and shape of values is not equals to a shape from the argument. z6allow_broadcast and verify_shape are not both allowed.NzNone values not supported.r(rzExpected values z! to be a dense tensor with shape z, but got shape .zUnrecognized data type: base_dtypez`dtype` z is not compatible with z of dtype T)zExpected Tensor's shape: rz*Too many elements provided. Takes at most d)r)r rlz>Cannot create a tensor proto whose content is larger than 2GB.zFailed to convert elements of z to Tensor. Consider casting elements to a supported type. See https://www.tensorflow.org/api_docs/python/tf/dtypes for supported TF dtypes.z+Element type not supported in TensorProto: )8rrr TensorProtoras_dtypeqint8quint8qint16quint16qint32rrrrrgenericis_numpy_compatiblerWr/prodint64emptyrnp_arrayrrrr)float64float32int32 array_equalrhasattrrrintras_datatype_enumr as_shapeas_proto_TENSOR_CONTENT_TYPESitemsizer:tensor_contentstringrr rrr ravelrr)rr)r verify_shapeallow_broadcastrnparraynp_dtdowncasted_array numpy_dtype is_same_size shape_sizerr"r#r str_values append_fns rrrs$v M NN ../ M OOE "E ,, v}}fnn -- F  $ $V ,FRZZ01 ** e223gg ~ 3 44 **""ee RWWU"((;q@e,g&%%fe4g w}} !4V!< <+F84""5f"=!>>N /034 4  #rzz*g --288 # 1 (' 2" .+ .w}}oQ? @@K | <!,, 0F0FF hug%=fXF$]]O1. // ] MMELJ!& '#SX 'E 'bhh/J-L $ '--57": <<: %3E%L>"==/,- - '--5<73E%L>"==/,- -  "E&q>GLL3C1FG G''  ( (((/88:<,k%::zA~||g&&&73  J LL")//"3L FMM!*VRZZ*H$V,L20<=1FOOA&=j= "":. ,|112)  5k6F6F5GqI KK L,' E (`> 2 6vh?11 222s$(V VV!VVV. make_ndarrayc  |jjDcgc]}|j}}tj|tj }t j|j}|j}|jr>tj|j|jj|S|t jk(rlt|j }|t#|z }|dkDr|r|dnd}|j%|g|ztj&||j|S|t j(k(s|t j*k(r8tj,|j.tj0}||_na|t j2t j4fvr8tj,|j6tj8}||_n|t j:k(r#tj,|j<|}n|t j>k(r#tj,|j@|}n|t jBt j8t j0t jDt jFt jHt jJt jLt jNt jPt jRt jTf vr#tj,|jV|}n|t j k(r#tj,|jX|}n|t jZk(r#tj,|j\|}nT|t j^k(r#tj,|j`|}n|t jbk(rUte|jf} tj&ti| | D cgc]} tk| d| dc} |}n|t jlk(rUte|jn} tj&ti| | D cgc]} tk| d| dc} |}nN|t jpk(r"tj,|jr|}ntud|jd|jdk(rtjv||S|j|k7r&tjx|d||jz fd}|j|Scc}wcc} wcc} w) a\Create a numpy ndarray from a tensor. Create a numpy ndarray with the same shape and data as the tensor. For example: ```python # Tensor a has shape (2,3) a = tf.constant([[1,2,3],[4,5,6]]) proto_tensor = tf.make_tensor_proto(a) # convert `tensor a` to a proto tensor tf.make_ndarray(proto_tensor) # output: array([[1, 2, 3], # [4, 5, 6]], dtype=int32) # output has shape (2,3) ``` Args: tensor: A TensorProto. Returns: A numpy array with the tensor contents. Raises: TypeError: if tensor has unsupported type. r(rrzUnsupported tensor type: zS. See https://www.tensorflow.org/api_docs/python/tf/dtypes for supported TF dtypes.edge)=r rrrrrrrr)r/r frombuffercopyreshaperrrrr arrayrr.fromiterrrr8r@r7r9rr`rrerint16rXrrrrrrVr]rYrluint32rquint64rt complex64iterrwzipcomplex complex128rboolrrzerospad) tensorrr num_elements tensor_dtyper)rpaddinglastitrs r MakeNdarrayrs6"..22 3a166 3% 3bhh/,.,  % %%  MM&// % ''+tvggen>V]]" &## $FS[(G{!VBZrd mmTFW$% 88F% ( 0 0 77V^^#|v'F[[ :FFL  [[**"(( ;FFLv~~% [[)) 7Fv~~% [[**% 8F ll ll mm ll kk mm mm ll mm nn kk ll  [[u 5Fv||# [[)) 7Fv}}$ [[**% 8Fv}}$ [[**% 8Fv''' f!! "B XXCBK@qwqtQqT*@ NFv((( f!! "B XXCBK@qwqtQqT*@ NFv{{" [[ 6F / ~>// 00 [[A 88E5 !! [[L VVFQ v{{ :;V DF  S 4pAAsU1-U6U;ct|tjstdt |dt|t j r$|jDcgc]}|j}}n.t|ttfstdt |d|jjDcgc]}|j}}tdt||DScc}wcc}w)aoReturns True if "tensor_proto" has the given "shape". Args: tensor_proto: A TensorProto. shape: A tensor shape, expressed as a TensorShape, list, or tuple. Returns: True if "tensor_proto" has the given "shape", otherwise False. Raises: TypeError: If "tensor_proto" is not a TensorProto, or shape is not a TensorShape, list, or tuple. zE`tensor_proto` must be a tensor_pb2.TensorProto object, but got type rz.`shape` must be a list or tuple, but got type c3,K|] \}}||k(ywrr).0rys r zShapeEquals..As >1Q!V >s)rrrrrrTensorShapeProtorrrrr allr)r"rrtensor_shape_lists r ShapeEqualsr(*s L*"8"8 9 $$($6#7q: ;;'889"YY 'QVV 'E ' edE] + DE{m1& '''3'@'@'D'DE!qvvEE >$5u = > >> (Fs C(7C-ct|tjst|dt |d|j jdk(r$t |j jdS|j jdk(r|j jdj}|jrMtj|jDcgc]}|jc}|jj Sy|j jdk(r|j jdj}|jrGtj"|jDcgc]}|jc}tj$Sy|j jd k(r|j jdj}|j&Ttj(d tj|j&gtj$tj$ Sy|j jd k(rt+|j jd}|yt+|j jd }|yt+|j jd}|ytj,||||jj S|j jdk(rnt+|j jd}|yt/j0|j jd}|j3|j S|j jdk(r|t+|j jd}|yg} |j jd dD]"} t+| } | y| j5| $tj6| |S|j jdk(r|t+|j jd}|yg} |j jddD]"} t+| } | y| j5| $tj6| |S|j jdk(rg} |j jsy|j jddk7ry|j jD]%} t+| |} | |sy| j5| ' tj| S|j jdk(rT|j jddk7ryt+|j jd|} | y| |j<S|j jdk(rt+|j jd}t+|j jd |} | |ytj>| |j jd|} | |j<S|j jdk(rq|j@} t+|j jd }| jr2|0tjB| jE||jSy|j jdk(r`t+|j jd}|yt+|j jd }|ytjF||S|j jdk(r`t+|j jd}|yt+|j jd }|ytjH||S|j jdk(r#t+|j jd|S|j jdvr#t+|j jd|Sycc}wcc}w#t8$rtj| t:cYSwxYw)Nz must be a Tensor, but got rConstvalueShaperr(SizeRankr)rbufferr)RangerCastDstTConcat)axisConcatV2rPackr5UnpackSplit num_splitFillEqualNotEqual StopGradient)CheckNumericsV2DebugIdentityV2Identity)%rr rrroprget_attrinputs get_shapeis_fully_definedrr dimsr+r)r/rrndimsrconstant_valuearangerrrWappend concatenaterobject value_indexsplitrfullas_listequal not_equal)rpartial input_shaperstartlimitdeltapre_cast cast_dtyperrr+rO fill_shape fill_valuevalue1value2s r_ConstantValuer_Ds FDKK ( vj ;DL>K LL YY^^w vyy))'2 33 yy~~ ))""1%//1K##% XX + 0 0 1399 1 ++-- yy~~))""1%//1K##% WW;+;+;  yy~~ 699++A. /E }  699++A. /E }  699++A. /E }  99UE5 0K0K LL yy~~fii..q12H !3!3F!;>&s ++ yy~~# ))"- .C {  F YY  cr "Qe  mmE  >>&s ++ yy~~ F 99    yy&!Q&  YY  Q(e w mmE  , XXf yy~~! yy&!Q&  699++A. 8E }  ## $$ yy~~ ))!, -C 699++A. 8E }  HHUFII..{;S AE ## $$ yy~~J 0 0 34J""$)? WWZ''):Z=M=M NN  yy~~ FII,,Q/ 0F ~  FII,,Q/ 0F ~  88FF ## yy~~# FII,,Q/ 0F ~  FII,,Q/ 0F ~  << '' yy~~' &))**1-w 77 yy~~KK &))**1-w 77 s 2=H , XXfF ++,sa=a?a!!$bbget_static_valuec0t|tjr |jSt |s|St|tjsyt||}||jj||S#tj $rYywxYw)aReturns the constant value of the given tensor, if efficiently calculable. This function attempts to partially evaluate the given tensor, and returns its value as a numpy ndarray if this succeeds. Example usage: >>> a = tf.constant(10) >>> print(tf.get_static_value(a)) 10 >>> b = tf.constant(20) >>> print(tf.get_static_value(tf.add(a, b))) 30 >>> # `tf.Variable` is not supported. >>> c = tf.Variable(30) >>> print(tf.get_static_value(c)) None Using `partial` option is most relevant when calling `get_static_value` inside a `tf.function`. Setting it to `True` will return the results but for the values that cannot be evaluated will be `None`. For example: ```python class Foo: def __init__(self): self.a = tf.Variable(1) self.b = tf.constant(2) @tf.function def bar(self, partial): packed = tf.raw_ops.Pack(values=[self.a, self.b]) static_val = tf.get_static_value(packed, partial=partial) tf.print(static_val) f = Foo() f.bar(partial=True) # `array([None, array(2, dtype=int32)], dtype=object)` f.bar(partial=False) # `None` ``` Compatibility(V1): If `constant_value(tensor)` returns a non-`None` result, it will no longer be possible to feed a different value for `tensor`. This allows the result of this function to influence the graph that is constructed, and permits static shape optimizations. Args: tensor: The Tensor to be evaluated. partial: If True, the returned numpy array is allowed to have partially evaluated values. Values that can't be evaluated will be None. Returns: A numpy ndarray containing the constant value of the given `tensor`, or None if it cannot be calculated. Raises: TypeError: if tensor is not an tensor.Tensor. N) rr rnumpyrUnimplementedError is_tensorrr_graphprevent_feeding)rrTrets rrIrIsv # \\^ 6  M FDKK ( vw'#_ LL  ( *  ) )sA??BBc  t|tjr8tj|j Dcgc] }|dk7r|nd c}S|j jdk(r@t|}| td|dk7rtd|dtjS|j jd}|dgk(rtjgS|jjdk(r$t|jjd}|j |St#j$|jj'd }|t"j(t"j*fvr,tj|j dj,St/j0|j3Dcgc]}||nd c}j5|j6}tj|Dcgc] }|dk\r|nd c}S|jjd k(r'|jjdj S|jjd k(rtjg}|jj'd dk(sJ|jjD]Q} t| } | | dkrtj8d} ntj8| } |j;| g}S|S|jjd k(rOtjg}|jjddD]} |j;t| }|S|jjdk(rOtjg}|jjddD]} |j;t| }|S|jjdk(r} t|jjd} t|jjd}t|jjd}| || | d} |d}|d}|jj'd}|dk(rd} |jj'd}|dk(rd}|jj'd}|jj'd}|jj'd}| xr | xr| xr| xs|dk(xr | xs|dk(}|rAt|jjd}|| ||}tj|}|Sn|jjdk(r|jj>j@rtC|jj>dretE|jj>jFD]9\}}||us |jj>jH|}t|cStj|j dj,}t|}|9|jKtj|Dcgc] }|dk\r|nd c}}|Scc}wcc}wcc}w#t$rYt<$rYwxYwcc}w)aqA version of `constant_value()` that returns a `TensorShape`. This version should be used when a constant tensor value is interpreted as a (possibly partial) shape, e.g. in the shape function for `tf.reshape()`. By explicitly requesting a `TensorShape` as the return value, it is possible to represent unknown dimensions; by contrast, `constant_value()` is all-or-nothing. Args: tensor: The rank-0 or rank-1 Tensor to be evaluated. Returns: A `TensorShape` based on the constant value of the given `tensor`. Raises: ValueError: If the shape is rank-0 and is not statically known to be -1. rNrz~Received a scalar with unknown value as shape; require a statically known scalar with value '-1' to describe an unknown shape.zReceived a scalar value 'z[' as shape; require a statically known scalar with value '-1' to describe an unknown shape.rr2r3r,r7r5r4r6 StridedSlicer1 begin_maskend_mask ellipsis_mask new_axis_maskshrink_axis_mask Placeholderinternal_captures)&rr rr TensorShaperbrErHrIr unknown_shape with_rankrBrconstant_value_as_shaperDrGrrrCrrr+rr rQrWr/ DimensionrLrrebuilding_functionr enumeraterqexternal_captures merge_with)rrr+rrYrZrdest_dtype_shape_arrayrg pack_inputpack_input_valnew_dim concat_inputbeginendstridesrkrlrmrnrovalid_attributesprevicaptureexternal_capturers rrurusS& #  # #/5||~>r t #> @@ " 6 "E }  G HH {  %eW-G G HH  % % ''     & &q )% qc\  # #B '' yy~~&vyy'7'7':;H}} o!3!3F!;A#5((.((8 OOWI &c' J yy~~!  " "2 &C ((,C  OO3LA BcC J yy~~#  " "2 &C (("-C  OO3LA BcC J yy~~' VYY--a01e 699++A. /cvyy//23g  s73Fa!f!*YY'' 5 ?%99%%j1 q=# **?;  **?; !99--.@A -->m2C> 00>:Dn7H7AQ>"*\rArCrFrIrMrOrRrTr[r^rrAppendFloat32ArrayToTensorProtorAppendFloat64ArrayToTensorProtorAppendInt32ArrayToTensorProtorAppendInt64ArrayToTensorProtor9AppendUInt8ArrayToTensorProtorAppendUInt16ArrayToTensorProtorAppendUInt32ArrayToTensorProtorAppendUInt64ArrayToTensorProtorXAppendInt8ArrayToTensorProtorAppendInt16ArrayToTensorProtor!AppendComplex64ArrayToTensorProtor"AppendComplex128ArrayToTensorProtoobject_rbool_AppendBoolArrayToTensorProtorr/rrrrr.r8r@rErLrQrVr]rrarfrjrmrorrrur|rrrrrrrr frozensetrrrrintegral_typesrvr real_typesr complex_typesrbytes_or_text_types _check_strr _check_boolrrrrrrrr(r_rIruruntime_checkabler NativeObjectTensorrrrdrrrrrsr( 06?.34(,)'/6 &: $ G OF  O Q**/jj8/jj"BB/ jj"BB/ hh >> /  hh >> /  hh >> / ii!@@/ ii!@@/ ii!@@/ gg<</ hh >>/ ll$FF/ mm%HH/ jj"AA/ hh ==/  ll!!  7 7#/& mm""  8 8)/, mm""  8 8 nn##  9 9 mm""  8 8 oo$$&J '')O )) 2 ++ 4 .. 7 ++ 4 kk  "B ll!!#D]/dDEBDEEEDDOC oo$$&J '')O )) 2   jj5  jj5 jj5 hh/ hh1 hh/ ii0 ii3 ii3 gg.  hh/!" ll9#$ mm;%& jj4'( hh0 ll!!#C mm""$D mm""$D nn##%E mm""$D kk  "B ll!!#D7> 8 )H" NN NN NN LL LL LL KK LL LL MM MM NN MM MM MM      OO+#8 .( L2235 )&*;*;< +F,@,@A '(B(B C (. &  KK ~ n NNL   NNL   NNL  LL* LL* LL* KK MM# MM# LL" NN$ MM#  MM:!" MM:#$ LL* MM: MM:) 07<&* CH&+K K^ >ccL?4CL J J ZL ^ 8  (($++|D ;((>   QY%& %&s_::``