package tensorflow

Get desktop application:
View/edit binary Protocol Buffers messages

EventListener: Receives Event protos, e.g., from debugged TensorFlow runtime(s).

• rpc SendEvents (stream Event, stream EventReply)

  debug_service.proto:93

  Client(s) can use this RPC method to send the EventListener Event protos. The Event protos can hold information such as: 1) intermediate tensors from a debugged graph being executed, which can be sent from DebugIdentity ops configured with grpc URLs. 2) GraphDefs of partition graphs, which can be sent from special debug ops that get executed immediately after the beginning of the graph execution.

• rpc SendTracebacks (CallTraceback, EventReply)

  debug_service.proto:96

  Send the tracebacks of a TensorFlow execution call.

  message CallTraceback

  debug_service.proto:53

  Data on the traceback of a debugged call, e.g., a Session.run() call, or the execution of an eager operation.

  • CallTraceback.CallType call_type = 1

  • string call_key = 2

    A key for the call. For example, for graph execution, this is a key consisting of the names of the fed and fetched tensors.

  • optional tfprof.CodeDef origin_stack = 3

    Traceback stack for the origin of the call event. For graph execution, this is the stack of the Session.run() call. For eager execution, this is the stack of the Python line that invokes the execution of the eager op.

  • map<int64, string> origin_id_to_string = 4

    Keeps track of the mapping from integer IDs in `origin_stack` to actual string values (e.g., file paths, function names).

  • optional tfprof.OpLogProto graph_traceback = 5

    Traceback for the graph (if any) involved in the call.

  • int64 graph_version = 6

    Version of the graph in `graph_traceback` (if any).

• rpc SendSourceFiles (DebuggedSourceFiles, EventReply)

  debug_service.proto:99

  Send a collection of source code files being debugged.

  message DebuggedSourceFiles

  debug.proto:81

  • repeated DebuggedSourceFile source_files = 1

    A collection of source code files.

////////////////////////////////////////////////////////////////////////////// TPUProfileAnalysis service provide entry point for profiling TPU and for serving profiled data to Tensorboard through GRPC //////////////////////////////////////////////////////////////////////////////

• rpc NewSession (NewProfileSessionRequest, NewProfileSessionResponse)

  tpu_profiler_analysis.proto:63

  Starts a profiling session, blocks until it completes. TPUProfileAnalysis service delegate this to TPUProfiler service. Populate the profiled data in repository, then return status to caller.

  message NewProfileSessionRequest

  tpu_profiler_analysis.proto:6

  • optional ProfileRequest request = 1

  • string repository_root = 2

  • repeated string hosts = 3

  message NewProfileSessionResponse

  tpu_profiler_analysis.proto:12

  • string error_message = 1

    Auxiliary error_message.

  • string session_id = 2

    If success, return session identifier for future reference.

• rpc EnumSessions (EnumProfileSessionsAndToolsRequest, EnumProfileSessionsAndToolsResponse)

  tpu_profiler_analysis.proto:66

  Enumerate existing sessions and return available profile tools.

  message EnumProfileSessionsAndToolsRequest

  tpu_profiler_analysis.proto:19

  • string repository_root = 1

  message EnumProfileSessionsAndToolsResponse

  tpu_profiler_analysis.proto:29

  • string error_message = 1

    Auxiliary error_message.

  • repeated ProfileSessionInfo sessions = 2

    If success, the returned sessions information are stored here.

• rpc GetSessionToolData (ProfileSessionDataRequest, ProfileSessionDataResponse)

  tpu_profiler_analysis.proto:70

  Retrieve specific tool's data for specific session.

  message ProfileSessionDataRequest

  tpu_profiler_analysis.proto:36

  • string repository_root = 1

  • string session_id = 2

  • string tool_name = 3

    Which tool

  • map<string, string> parameters = 4

    Tool's specific parameters. e.g. TraceViewer's viewport etc

  message ProfileSessionDataResponse

  tpu_profiler_analysis.proto:45

  • string error_message = 1

    Auxiliary error_message.

  • string output_format = 2

    Output format. e.g. "json" or "proto" or "blob"

  • bytes output = 3

    TODO(jiesun): figure out whether to put bytes or oneof tool specific proto.

The TPUProfiler service retrieves performance information about the programs running on connected TPUs over a period of time.

• rpc Profile (ProfileRequest, ProfileResponse)

  tpu_profiler.proto:12

  Starts a profiling session, blocks until it completes, and returns data.

  message ProfileResponse

  tpu_profiler.proto:78

  • repeated GraphDef computation_graph = 2

    Graphs of programs executed on TPUs during the profiling period.

  • optional RunMetadata hlo_metadata = 5

    Performance profile that can be used to annotate HLO operations in the computation graph.

  • bytes encoded_trace = 3

    Encoded Trace proto message that contains metadata about the trace captured during the profiling period. Describes the devices and resources that 'trace_events' refers to.

  • optional tpu.op_profile.Profile op_profile = 4

    Assembles a hierarchical performance profile based on HLOs in trace events. If the trace covers multiple programs, the longest-running one is analyzed. See op_profile.proto for the detailed semantics of the returned profile.

  • repeated ProfileToolData tool_data = 6

    Data payload for each required tools.

    next-field: 7

• rpc GetRemoteAddress (GetRemoteAddressRequest, GetRemoteAddressResponse)

  verbs_service.proto:66

  message GetRemoteAddressRequest

  verbs_service.proto:41

  • string host_name = 1

  • optional Channel channel = 2

  • repeated MemoryRegion mr = 3

  message GetRemoteAddressResponse

  verbs_service.proto:47

  • string host_name = 1

  • optional Channel channel = 2

  • repeated MemoryRegion mr = 3

Used in: NodeExecStats, TensorDescription

• int64 requested_bytes = 1

  Total number of bytes requested

• int64 allocated_bytes = 2

  Total number of bytes allocated if known

• string allocator_name = 3

  Name of the allocator used

• int64 allocation_id = 4

  Identifier of the allocated buffer if known

• bool has_single_reference = 5

  Set if this tensor only has one remaining reference

• uint64 ptr = 6

  Address of the allocation.

An allocation/de-allocation operation performed by the allocator.

Used in: AllocatorMemoryUsed, tfprof.ExecProfile

• int64 alloc_micros = 1

  The timestamp of the operation.

• int64 alloc_bytes = 2

  Number of bytes allocated, or de-allocated if negative.

Used in: NodeExecStats

• string allocator_name = 1

• int64 total_bytes = 2

  These are per-node allocator memory stats.

• int64 peak_bytes = 3

• int64 live_bytes = 4

  The bytes that are not deallocated.

• repeated AllocationRecord allocation_records = 6

  The allocation and deallocation timeline.

• int64 allocator_bytes_in_use = 5

  These are snapshots of the overall allocator memory stats. The number of live bytes currently allocated by the allocator.

Used to specify and override the default API & behavior in the generated code for client languages, from what you would get from the OpDef alone. There will be a set of ApiDefs that are common to all client languages, and another set per client language. The per-client-language ApiDefs will inherit values from the common ApiDefs which it can either replace or modify. We separate the API definition from the OpDef so we can evolve the API while remaining backwards compatible when interpretting old graphs. Overrides go in an "api_def.pbtxt" file with a text-format ApiDefs message. WARNING: Be *very* careful changing the API for any existing op -- you can change the semantics of existing code. These changes may need to wait until a major release of TensorFlow to avoid breaking our compatibility promises.

Used in: ApiDefs

• string graph_op_name = 1

  Name of the op (in the OpDef) to specify the API for.

• ApiDef.Visibility visibility = 2

• repeated ApiDef.Endpoint endpoint = 3

• repeated ApiDef.Arg in_arg = 4

• repeated ApiDef.Arg out_arg = 5

• repeated string arg_order = 11

  List of original in_arg names to specify new argument order. Length of arg_order should be either empty to keep current order or match size of in_arg.

• repeated ApiDef.Attr attr = 6

• string summary = 7

  One-line human-readable description of what the Op does.

• string description = 8

  Additional, longer human-readable description of what the Op does.

• string description_prefix = 9

  Modify an existing/inherited description by adding text to the beginning or end.

• string description_suffix = 10

Used in: ApiDef

• string name = 1

• string rename_to = 2

  Change the name used to access this arg in the API from what is used in the GraphDef. Note that these names in `backticks` will also be replaced in the summary & description fields.

• string description = 3

  Note: this will replace any inherited arg doc. There is no current way of modifying arg descriptions (other than replacing them entirely) as can be done with op descriptions.

Description of the graph-construction-time configuration of this Op. That is to say, this describes the attr fields that will be specified in the NodeDef.

Used in: ApiDef

• string name = 1

• string rename_to = 2

  Change the name used to access this attr in the API from what is used in the GraphDef. Note that these names in `backticks` will also be replaced in the summary & description fields.

• optional AttrValue default_value = 3

  Specify a new default value to use for this attr. This default will be used when creating new graphs, as opposed to the default in the OpDef, which will be used when interpreting old GraphDefs.

• string description = 4

  Note: this will replace any inherited attr doc, there is no current way of modifying attr descriptions as can be done with op descriptions.

If you specify any endpoint, this will replace all of the inherited endpoints. The first endpoint should be the "canonical" endpoint, and should not be deprecated (unless all endpoints are deprecated).

Used in: ApiDef

• string name = 1

  Name should be either like "CamelCaseName" or "Package.CamelCaseName". Client-language-specific ApiDefs may use a snake_case convention instead of CamelCase.

• int32 deprecation_version = 2

  First GraphDef version at which the op is disallowed.

Used in: ApiDef

• DEFAULT_VISIBILITY = 0

  Normally this is "VISIBLE" unless you are inheriting a different value from another ApiDef.

• VISIBLE = 1

  Publicly visible in the API.

• SKIP = 2

  Do not include this op in the generated API. If visibility is set to 'SKIP', other fields are ignored for this op.

• HIDDEN = 3

  Hide this op by putting it into an internal namespace (or whatever is appropriate in the target language).

• repeated ApiDef op = 1

An asset file def for a single file or a set of sharded files with the same name.

Used in: MetaGraphDef

• optional TensorInfo tensor_info = 1

  The tensor to bind the asset filename to.

• string filename = 2

  The filename within an assets directory. Note: does not include the path prefix, i.e. directories. For an asset at /tmp/path/vocab.txt, the filename would be "vocab.txt".

Protocol buffer representing the value for an attr used to configure an Op. Comment indicates the corresponding attr type. Only the field matching the attr type may be filled.

Used in: ApiDef.Attr, FunctionDef, KernelDef.AttrConstraint, NameAttrList, NodeDef, OpDef.AttrDef, OpInfo, tfprof.ProfileNode

• oneof value

  • bytes s = 2

    "string"

  • int64 i = 3

    "int"

  • float f = 4

    "float"

  • bool b = 5

    "bool"

  • DataType type = 6

    "type"

  • TensorShapeProto shape = 7

    "shape"

  • TensorProto tensor = 8

    "tensor"

  • AttrValue.ListValue list = 1

    any "list(...)"

  • NameAttrList func = 10

    "func" represents a function. func.name is a function's name or a primitive op's name. func.attr.first is the name of an attr defined for that function. func.attr.second is the value for that attr in the instantiation.

  • string placeholder = 9

    This is a placeholder only used in nodes defined inside a function. It indicates the attr value will be supplied when the function is instantiated. For example, let us suppose a node "N" in function "FN". "N" has an attr "A" with value placeholder = "foo". When FN is instantiated with attr "foo" set to "bar", the instantiated node N's attr A will have been given the value "bar".

LINT.IfChange

Used in: AttrValue

• repeated bytes s = 2

  "list(string)"

• repeated int64 i = 3

  "list(int)"

• repeated float f = 4

  "list(float)"

• repeated bool b = 5

  "list(bool)"

• repeated DataType type = 6

  "list(type)"

• repeated TensorShapeProto shape = 7

  "list(shape)"

• repeated TensorProto tensor = 8

  "list(tensor)"

• repeated NameAttrList func = 9

  "list(attr)"

Used in: RewriterConfig

• bool enable = 1

• int32 num_replicas = 2

Matches DeviceAttributes

Used in: MachineConfiguration

• string name = 1

  Device name.

• string type = 2

  Device type, e.g. 'CPU' or 'GPU'.

• int64 memory_limit = 3

  Memory capacity in bytes.

• string physical_description = 4

  The physical description of this device.

Used in: TestResults

• repeated BenchmarkEntry entry = 1

Each unit test or benchmark in a test or benchmark run provides some set of information. Here we provide some reasonable keys one would expect to see, with optional key/value pairs for things we haven't considered. This BenchmarkEntry should be emitted by each unit test or benchmark reporter.

Used in: BenchmarkEntries

• string name = 1

  The name of the specific benchmark or test (e.g. BM_AdjustContrast_gpu_B_W_H)

• int64 iters = 2

  If a benchmark, how many iterations it was run for

• double cpu_time = 3

  Total cpu time used for all iterations (in seconds)

• double wall_time = 4

  Total wall time used for all iterations (in seconds)

• double throughput = 5

  Throughput (in MB/s)

• map<string, EntryValue> extras = 6

  Generic map from result key to value.

This proto specifies a table partition in BigQuery.

• int64 start_index = 1

  [start_index, end_index] specify the boundaries of a partition. If end_index is -1, every row starting from start_index is part of the partition.

• int64 end_index = 2

Used in: TestResults

• string mode = 1

  opt, dbg, etc

• repeated string cc_flags = 2

  CC compiler flags, if known

• repeated string opts = 3

  Bazel compilation options, if known

Describes the metadata related to a checkpointed tensor.

• DataType dtype = 1

  The tensor dtype and shape.

• optional TensorShapeProto shape = 2

• int32 shard_id = 3

  The binary content of the tensor lies in: File "shard_id": bytes [offset, offset + size).

• int64 offset = 4

• int64 size = 5

• fixed32 crc32c = 6

  The CRC32C checksum of the tensor bytes.

• repeated TensorSliceProto slices = 7

  Iff present, this entry represents a partitioned tensor. The previous fields are interpreted as follows: "dtype", "shape": describe the full tensor. "shard_id", "offset", "size", "crc32c": all IGNORED. These information for each slice can be looked up in their own BundleEntryProto, keyed by each "slice_name".

Special header that is associated with a bundle. TODO(zongheng,zhifengc): maybe in the future, we can add information about which binary produced this checkpoint, timestamp, etc. Sometime, these can be valuable debugging information. And if needed, these can be used as defensive information ensuring reader (binary version) of the checkpoint and the writer (binary version) must match within certain range, etc.

• int32 num_shards = 1

  Number of data files in the bundle.

• BundleHeaderProto.Endianness endianness = 2

• optional VersionDef version = 3

  Versioning of the tensor bundle format.

An enum indicating the endianness of the platform that produced this bundle. A bundle can only be read by a platform with matching endianness. Defaults to LITTLE, as most modern platforms are little-endian. Affects the binary tensor data bytes only, not the metadata in protobufs.

Used in: BundleHeaderProto

• LITTLE = 0

• BIG = 1

Containers to hold repeated fundamental values.

Used in: Feature

• repeated bytes value = 1

Used in: MachineConfiguration

• int64 num_cores = 1

• int64 num_cores_allowed = 2

• double mhz_per_cpu = 3

  How fast are these cpus?

• string cpu_info = 4

  Additional cpu information. For example, Intel Ivybridge with HyperThreading (24 cores) dL1:32KB dL2:256KB dL3:30MB

• string cpu_governor = 5

  What kind of cpu scaling is enabled on the host. Examples include "performance", "ondemand", "conservative", "mixed".

• map<string, int64> cache_size = 6

  Cache sizes (in bytes), e.g. "L2": 262144 (for 256KB)

Used in: CallTraceback

• UNSPECIFIED = 0

• GRAPH_EXECUTION = 1

• EAGER_EXECUTION = 2

Defines a subgraph in another `GraphDef` as a set of feed points and nodes to be fetched or executed. Compare with the arguments to `Session::Run()`.

Used in: MakeCallableRequest

• repeated string feed = 1

  Tensors to be fed in the callable. Each feed is the name of a tensor.

• repeated string fetch = 2

  Fetches. A list of tensor names. The caller of the callable expects a tensor to be returned for each fetch[i] (see RunStepResponse.tensor). The order of specified fetches does not change the execution order.

• repeated string target = 3

  Target Nodes. A list of node names. The named nodes will be run by the callable but their outputs will not be returned.

• optional RunOptions run_options = 4

  Options that will be applied to each run.

• repeated TensorConnection tensor_connection = 5

  Tensors to be connected in the callable. Each TensorConnection denotes a pair of tensors in the graph, between which an edge will be created in the callable.

Used in: GetRemoteAddressRequest, GetRemoteAddressResponse

• int32 lid = 1

• int32 qpn = 2

• int32 psn = 3

• uint64 snp = 4

• uint64 iid = 5

Protocol buffer representing the checkpoint state. TODO(touts): Add other attributes as needed.

• string model_checkpoint_path = 1

  Path to the most-recent model checkpoint.

• repeated string all_model_checkpoint_paths = 2

  Paths to all not-yet-deleted model checkpoints, sorted from oldest to newest. Note that the value of model_checkpoint_path should be the last item in this list.

Used as request type in: grpc.WorkerService.CleanupAll

• repeated string container = 1

  A list of container names. If 'container' is not empty, releases resources in the given containers in all devices. If 'container' is empty, releases resources in the default container in all devices.

Used as response type in: grpc.WorkerService.CleanupAll

(message has no fields)

Used as request type in: grpc.WorkerService.CleanupGraph

• int64 step_id = 1

Used as response type in: grpc.WorkerService.CleanupGraph

(message has no fields)

Used as request type in: grpc.MasterService.CloseSession

• string session_handle = 1

  REQUIRED: session_handle must be returned by a CreateSession call to the same master service.

Used as response type in: grpc.MasterService.CloseSession

(message has no fields)

Defines a TensorFlow cluster as a set of jobs.

Used in: ConfigProto, ServerDef

• repeated JobDef job = 1

  The jobs that comprise the cluster.

CollectionDef should cover most collections. To add a user-defined collection, do one of the following: 1. For simple data types, such as string, int, float: tf.add_to_collection("your_collection_name", your_simple_value) strings will be stored as bytes_list. 2. For Protobuf types, there are three ways to add them: 1) tf.add_to_collection("your_collection_name", your_proto.SerializeToString()) collection_def { key: "user_defined_bytes_collection" value { bytes_list { value: "queue_name: \"test_queue\"\n" } } } or 2) tf.add_to_collection("your_collection_name", str(your_proto)) collection_def { key: "user_defined_string_collection" value { bytes_list { value: "\n\ntest_queue" } } } or 3) any_buf = any_pb2.Any() tf.add_to_collection("your_collection_name", any_buf.Pack(your_proto)) collection_def { key: "user_defined_any_collection" value { any_list { value { type_url: "type.googleapis.com/tensorflow.QueueRunnerDef" value: "\n\ntest_queue" } } } } 3. For Python objects, implement to_proto() and from_proto(), and register them in the following manner: ops.register_proto_function("your_collection_name", proto_type, to_proto=YourPythonObject.to_proto, from_proto=YourPythonObject.from_proto) These functions will be invoked to serialize and de-serialize the collection. For example, ops.register_proto_function(ops.GraphKeys.GLOBAL_VARIABLES, proto_type=variable_pb2.VariableDef, to_proto=Variable.to_proto, from_proto=Variable.from_proto)

Used in: MetaGraphDef

• oneof kind

  • CollectionDef.NodeList node_list = 1

  • CollectionDef.BytesList bytes_list = 2

  • CollectionDef.Int64List int64_list = 3

  • CollectionDef.FloatList float_list = 4

  • CollectionDef.AnyList any_list = 5

AnyList is used for collecting Any protos.

Used in: CollectionDef

• repeated google.protobuf.Any value = 1

BytesList is used for collecting strings and serialized protobufs. For example: collection_def { key: "trainable_variables" value { bytes_list { value: "\n\017conv1/weights:0\022\024conv1/weights/Assign \032\024conv1/weights/read:0" value: "\n\016conv1/biases:0\022\023conv1/biases/Assign\032 \023conv1/biases/read:0" } } }

Used in: CollectionDef

• repeated bytes value = 1

FloatList is used for collecting float values.

Used in: CollectionDef

• repeated float value = 1

Int64List is used for collecting int, int64 and long values.

Used in: CollectionDef

• repeated int64 value = 1

NodeList is used for collecting nodes in graph. For example collection_def { key: "summaries" value { node_list { value: "input_producer/ScalarSummary:0" value: "shuffle_batch/ScalarSummary:0" value: "ImageSummary:0" } }

Used in: CollectionDef

• repeated string value = 1

Used in: TestResults

• oneof kind

  • int64 changelist = 1

    Submitted changelist.

  • string hash = 2

• string snapshot = 3

  Hash of intermediate change between hash/changelist and what was tested. Not used if the build is from a commit without modifications.

• int64 pending_changelist = 4

  Changelist tested if the change list is not already submitted.

Protocol buffer representing a CondContext object.

Used in: ControlFlowContextDef

• string context_name = 1

  Name of the context.

• string pred_name = 2

  Name of the pred tensor.

• string pivot_name = 3

  Name of the pivot tensor.

• int32 branch = 4

  Branch prediction. 0 or 1.

• optional ValuesDef values_def = 5

  Values and external values in control flow context.

• repeated ControlFlowContextDef nested_contexts = 6

  Contexts contained inside this context (e.g. nested conds).

Session configuration parameters. The system picks appropriate values for fields that are not set.

Used in: CreateSessionRequest, ServerDef

• map<string, int32> device_count = 1

  Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use. If a particular device type is not found in the map, the system picks an appropriate number.

• int32 intra_op_parallelism_threads = 2

  The execution of an individual op (for some op types) can be parallelized on a pool of intra_op_parallelism_threads. 0 means the system picks an appropriate number.

• int32 inter_op_parallelism_threads = 5

  Nodes that perform blocking operations are enqueued on a pool of inter_op_parallelism_threads available in each process. 0 means the system picks an appropriate number. Note that the first Session created in the process sets the number of threads for all future sessions unless use_per_session_threads is true or session_inter_op_thread_pool is configured.

• bool use_per_session_threads = 9

  If true, use a new set of threads for this session rather than the global pool of threads. Only supported by direct sessions. If false, use the global threads created by the first session, or the per-session thread pools configured by session_inter_op_thread_pool. This option is deprecated. The same effect can be achieved by setting session_inter_op_thread_pool to have one element, whose num_threads equals inter_op_parallelism_threads.

• repeated ThreadPoolOptionProto session_inter_op_thread_pool = 12

  This option is experimental - it may be replaced with a different mechanism in the future. Configures session thread pools. If this is configured, then RunOptions for a Run call can select the thread pool to use. The intended use is for when some session invocations need to run in a background pool limited to a small number of threads: - For example, a session may be configured to have one large pool (for regular compute) and one small pool (for periodic, low priority work); using the small pool is currently the mechanism for limiting the inter-op parallelism of the low priority work. Note that it does not limit the parallelism of work spawned by a single op kernel implementation. - Using this setting is normally not needed in training, but may help some serving use cases. - It is also generally recommended to set the global_name field of this proto, to avoid creating multiple large pools. It is typically better to run the non-low-priority work, even across sessions, in a single large pool.

• int32 placement_period = 3

  Assignment of Nodes to Devices is recomputed every placement_period steps until the system warms up (at which point the recomputation typically slows down automatically).

• repeated string device_filters = 4

  When any filters are present sessions will ignore all devices which do not match the filters. Each filter can be partially specified, e.g. "/job:ps" "/job:worker/replica:3", etc.

• optional GPUOptions gpu_options = 6

  Options that apply to all GPUs.

• bool allow_soft_placement = 7

  Whether soft placement is allowed. If allow_soft_placement is true, an op will be placed on CPU if 1. there's no GPU implementation for the OP or 2. no GPU devices are known or registered or 3. need to co-locate with reftype input(s) which are from CPU.

• bool log_device_placement = 8

  Whether device placements should be logged.

• optional GraphOptions graph_options = 10

  Options that apply to all graphs.

• int64 operation_timeout_in_ms = 11

  Global timeout for all blocking operations in this session. If non-zero, and not overridden on a per-operation basis, this value will be used as the deadline for all blocking operations.

• optional RPCOptions rpc_options = 13

  Options that apply when this session uses the distributed runtime.

• optional ClusterDef cluster_def = 14

  Optional list of all workers to use in this session.

• bool isolate_session_state = 15

  If true, any resources such as Variables used in the session will not be shared with other sessions.

Container for any kind of control flow context. Any other control flow contexts that are added below should also be added here.

Used in: CondContextDef, WhileContextDef

• oneof ctxt

  • CondContextDef cond_ctxt = 1

  • WhileContextDef while_ctxt = 2

Used in: RunGraphResponse, RunMetadata

• repeated CostGraphDef.Node node = 1

Used in: CostGraphDef

• string name = 1

  The name of the node. Names are globally unique.

• string device = 2

  The device of the node. Can be empty if the node is mapped to the default partition or partitioning hasn't been run yet.

• int32 id = 3

  The id of the node. Node ids are only unique inside a partition.

• repeated Node.InputInfo input_info = 4

• repeated Node.OutputInfo output_info = 5

• int64 temporary_memory_size = 6

  Temporary memory used by this node.

• int64 persistent_memory_size = 12

  Persistent memory used by this node.

• int64 host_temp_memory_size = 10

• int64 device_temp_memory_size = 11

• int64 device_persistent_memory_size = 16

• int64 compute_cost = 9

  Estimate of the computational cost of this node, in microseconds.

• int64 compute_time = 14

  Analytical estimate of the computational cost of this node, in microseconds.

• int64 memory_time = 15

  Analytical estimate of the memory access cost of this node, in microseconds.

• bool is_final = 7

  If true, the output is permanent: it can't be discarded, because this node is part of the "final output". Nodes may depend on final nodes.

• repeated int32 control_input = 8

  Ids of the control inputs for this node.

Inputs of this node. They must be executed before this node can be executed. An input is a particular output of another node, specified by the node id and the output index.

Used in: Node

• int32 preceding_node = 1

• int32 preceding_port = 2

Outputs of this node.

Used in: Node

• int64 size = 1

• int64 alias_input_port = 2

  If >= 0, the output is an alias of an input. Note that an alias input may itself be an alias. The algorithm will therefore need to follow those pointers.

• optional TensorShapeProto shape = 3

• DataType dtype = 4

• repeated int32 input_tensors_needed = 1

• repeated int32 input_tensors_as_shapes_needed = 2

• optional TensorShapeProto shape = 1

• optional CppShapeInferenceResult.HandleData handle_data = 4

Used in: CppShapeInferenceResult

• bool is_set = 1

• repeated HandleShapeAndType shape_and_type = 2

  Only valid if <is_set>.

Used in: HandleData

• optional TensorShapeProto shape = 1

• DataType dtype = 2

Used as request type in: grpc.MasterService.CreateSession

• optional GraphDef graph_def = 1

  The initial graph definition.

• optional ConfigProto config = 2

  Configuration options.

• string target = 3

  The target string used from the client's perspective.

Used as response type in: grpc.MasterService.CreateSession

• string session_handle = 1

  The session handle to be used in subsequent calls for the created session. The client must arrange to call CloseSession with this returned session handle to close the session.

• int64 graph_version = 2

  The initial version number for the graph, to be used in the next call to ExtendSession.

Used as request type in: grpc.WorkerService.CreateWorkerSession

• string session_handle = 1

  Sessions are identified by a given handle.

• optional ServerDef server_def = 2

  Defines the configuration of a TensorFlow worker.

• bool isolate_session_state = 3

  If true, any resources such as Variables used in the session will not be shared with other sessions.

Used as response type in: grpc.WorkerService.CreateWorkerSession

(message has no fields)

Protocol buffer representing a CriticalSection.

• string critical_section_name = 1

  Name of the critical section handle.

Protocol buffer representing a CriticalSection execution.

• string execute_in_critical_section_name = 1

  Name of the critical section handle.

• bool exclusive_resource_access = 2

  Whether this operation requires exclusive access to its resources, (i.e., no other CriticalSections may request the same resources).

LINT.IfChange

Used in: AttrValue, AttrValue.ListValue, BundleEntryProto, CostGraphDef.Node.OutputInfo, CppShapeInferenceResult.HandleShapeAndType, FixedLenFeatureProto, GraphTransferInfo.ConstNodeInfo, GraphTransferInfo.GraphInputNodeInfo, GraphTransferInfo.GraphOutputNodeInfo, OpDef.ArgDef, OpInfo.TensorProperties, RemoteFusedGraphExecuteInfo.TensorShapeTypeProto, SavedSliceMeta, TensorDescription, TensorInfo, TensorProto, VarLenFeatureProto, contrib.mpi_collectives.MPIRequest, tf2xla.Feed, tf2xla.TensorMetadata, tfprof.TFProfTensorProto

• DT_INVALID = 0

  Not a legal value for DataType. Used to indicate a DataType field has not been set.

• DT_FLOAT = 1

  Data types that all computation devices are expected to be capable to support.

• DT_DOUBLE = 2

• DT_INT32 = 3

• DT_UINT8 = 4

• DT_INT16 = 5

• DT_INT8 = 6

• DT_STRING = 7

• DT_COMPLEX64 = 8

  Single-precision complex

• DT_INT64 = 9

• DT_BOOL = 10

• DT_QINT8 = 11

  Quantized int8

• DT_QUINT8 = 12

  Quantized uint8

• DT_QINT32 = 13

  Quantized int32

• DT_BFLOAT16 = 14

  Float32 truncated to 16 bits. Only for cast ops.

• DT_QINT16 = 15

  Quantized int16

• DT_QUINT16 = 16

  Quantized uint16

• DT_UINT16 = 17

• DT_COMPLEX128 = 18

  Double-precision complex

• DT_HALF = 19

• DT_RESOURCE = 20

• DT_VARIANT = 21

  Arbitrary C++ data types

• DT_UINT32 = 22

• DT_UINT64 = 23

• DT_FLOAT_REF = 101

  Do not use! These are only for parameters. Every enum above should have a corresponding value below (verified by types_test).

• DT_DOUBLE_REF = 102

• DT_INT32_REF = 103

• DT_UINT8_REF = 104

• DT_INT16_REF = 105

• DT_INT8_REF = 106

• DT_STRING_REF = 107

• DT_COMPLEX64_REF = 108

• DT_INT64_REF = 109

• DT_BOOL_REF = 110

• DT_QINT8_REF = 111

• DT_QUINT8_REF = 112

• DT_QINT32_REF = 113

• DT_BFLOAT16_REF = 114

• DT_QINT16_REF = 115

• DT_QUINT16_REF = 116

• DT_UINT16_REF = 117

• DT_COMPLEX128_REF = 118

• DT_HALF_REF = 119

• DT_RESOURCE_REF = 120

• DT_VARIANT_REF = 121

• DT_UINT32_REF = 122

• DT_UINT64_REF = 123

EXPERIMENTAL. Options for initializing DebuggerState.

Used in: RegisterGraphRequest, RunOptions

• repeated DebugTensorWatch debug_tensor_watch_opts = 4

  Debugging options

• int64 global_step = 10

  Caller-specified global step count. Note that this is distinct from the session run count and the executor step count.

EXPERIMENTAL. Option for watching a node.

Used in: DebugOptions

• string node_name = 1

  Name of the node to watch.

• int32 output_slot = 2

  Output slot to watch. The semantics of output_slot == -1 is that the node is only watched for completion, but not for any output tensors. See NodeCompletionCallback in debug_gateway.h. TODO(cais): Implement this semantics.

• repeated string debug_ops = 3

  Name(s) of the debugging op(s). One or more than one probes on a tensor. e.g., {"DebugIdentity", "DebugNanCount"}

• repeated string debug_urls = 4

  URL(s) for debug targets(s). Supported URL formats are: - file:///foo/tfdbg_dump: Writes out Event content to file /foo/tfdbg_dump. Assumes all directories can be created if they don't already exist. - grpc://localhost:11011: Sends an RPC request to an EventListener service running at localhost:11011 with the event. - memcbk:///event_key: Routes tensors to clients using the callback registered with the DebugCallbackRegistry for event_key. Each debug op listed in debug_ops will publish its output tensor (debug signal) to all URLs in debug_urls. N.B. Session::Run() supports concurrent invocations of the same inputs (feed keys), outputs and target nodes. If such concurrent invocations are to be debugged, the callers of Session::Run() must use distinct debug_urls to make sure that the streamed or dumped events do not overlap among the invocations. TODO(cais): More visible documentation of this in g3docs.

• bool tolerate_debug_op_creation_failures = 5

  Do not error out if debug op creation fails (e.g., due to dtype incompatibility). Instead, just log the failure.

Used in: DebuggedSourceFiles

• string host = 1

  The host name on which a source code file is located.

• string file_path = 2

  Path to the source code file.

• int64 last_modified = 3

  The timestamp at which the source code file is last modified.

• int64 bytes = 4

  Byte size of the file.

• repeated string lines = 5

  Line-by-line content of the source code file.

Used as request type in: grpc.WorkerService.DeleteWorkerSession

• string session_handle = 1

  Sessions are identified by a given handle.

Used as response type in: grpc.WorkerService.DeleteWorkerSession

(message has no fields)

Used as request type in: grpc.WorkerService.DeregisterGraph

• string session_handle = 2

  The session_handle used when registering the graph. If session_handle is empty, a single global namespace is used.

• string graph_handle = 1

  REQUIRED: graph_handle must be returned by a RegisterGraph call to the same WorkerService.

TODO(mrry): Optionally add summary stats for the graph.

Used as response type in: grpc.WorkerService.DeregisterGraph

(message has no fields)

Used in: GetStatusResponse, ListDevicesResponse

• string name = 1

  Fully specified name of the device within a cluster.

• string device_type = 2

  String representation of device_type.

• int64 memory_limit = 4

  Memory capacity of device in bytes.

• optional DeviceLocality locality = 5

  Platform-specific data about device that may be useful for supporting efficient data transfers.

• fixed64 incarnation = 6

  A device is assigned a global unique number each time it is initialized. "incarnation" should never be 0.

• string physical_device_desc = 7

  String representation of the physical device that this device maps to.

Used in: DeviceAttributes, RecvTensorRequest

• int32 bus_id = 1

  Optional bus locality of device. Default value of 0 means no specific locality. Specific localities are indexed from 1.

• int32 numa_node = 2

  Optional NUMA locality of device.

• optional LocalLinks links = 3

  Optional local interconnect links to other devices.

Used in: NamedDevice, OpInfo

• string type = 1

  Device type (CPU, GPU, ...)

• string vendor = 2

  Vendor (Intel, nvidia, ...)

• string model = 3

  Model (Haswell, K40, ...)

• int64 frequency = 4

  Core Frequency in Mhz

• int64 num_cores = 5

  Number of cores

• map<string, string> environment = 6

  Version of the tools and libraries used with this device (e.g. gcc 4.9, cudnn 5.1)

• int64 num_registers = 7

  Number of registers per core.

• int64 l1_cache_size = 8

  L1 cache size in bytes

• int64 l2_cache_size = 9

  L2 cache size in bytes

• int64 l3_cache_size = 10

  L3 cache size in bytes

• int64 shared_memory_size_per_multiprocessor = 11

  Shared memory size per multiprocessor in bytes. This field is applicable to GPUs only.

• int64 memory_size = 12

  Memory size in bytes

• int64 bandwidth = 13

  Memory bandwidth in KB/s

Used in: StepStats

• string device = 1

• repeated NodeExecStats node_stats = 2

Used in: ProjectorConfig

• string tensor_name = 1

• string metadata_path = 2

• string bookmarks_path = 3

• repeated uint32 tensor_shape = 4

  Shape of the 2D tensor [N x D]. If missing, it will be inferred from the model checkpoint.

• optional SpriteMetadata sprite = 5

• string tensor_path = 6

  Path to the TSV file holding the tensor values. If missing, the tensor is assumed to be stored in the model checkpoint.

Used in: BenchmarkEntry

• oneof kind

  • double double_value = 1

  • string string_value = 2

• int32 error_code = 1

• string error_message = 2

• string error_details = 3

Protocol buffer representing an event that happened during the execution of a Brain model.

Used as request type in: EventListener.SendEvents

Used as field type in: SessionStatus

• double wall_time = 1

  Timestamp of the event.

• int64 step = 2

  Global step of the event.

• oneof what

  • string file_version = 3

    An event file was started, with the specified version. This is use to identify the contents of the record IO files easily. Current version is "brain.Event:2". All versions start with "brain.Event:".

  • bytes graph_def = 4

    An encoded version of a GraphDef.

  • Summary summary = 5

    A summary was generated.

  • LogMessage log_message = 6

    The user output a log message. Not all messages are logged, only ones generated via the Python tensorboard_logging module.

  • SessionLog session_log = 7

    The state of the session which can be used for restarting after crashes.

  • TaggedRunMetadata tagged_run_metadata = 8

    The metadata returned by running a session.run() call.

  • bytes meta_graph_def = 9

    An encoded version of a MetaGraphDef.

Reply message from EventListener to the client, i.e., to the source of the Event protocol buffers, e.g., debug ops inserted by a debugged runtime to a TensorFlow graph being executed.

Used as response type in: EventListener.SendEvents, EventListener.SendSourceFiles, EventListener.SendTracebacks

• repeated EventReply.DebugOpStateChange debug_op_state_changes = 1

• optional TensorProto tensor = 2

  New tensor value to override the current tensor value with.

  TODO(cais): Make use of this field to implement overriding of tensor value during debugging.

Used in: EventReply

• DebugOpStateChange.State state = 1

• string node_name = 2

• int32 output_slot = 3

• string debug_op = 4

Used in: DebugOpStateChange

• STATE_UNSPECIFIED = 0

• DISABLED = 1

• READ_ONLY = 2

• READ_WRITE = 3

• optional Features features = 1

• map<string, FeatureConfiguration> feature_map = 1

This message is parallel to Example, but with additional fields to test unknown fields handling in example_proto_fast_parsing_test.cc.

• optional Features features = 1

• string extra1 = 1337

• int64 extra2 = 1338

• fixed32 extra3 = 1339

• fixed64 extra4 = 1340

• double extra5 = 1341

• repeated float extra6 = 1342

• optional Features extra7 = 1343

Options specific to the execution of a single step.

Used in: RunGraphRequest

• bool record_costs = 1

• bool record_timeline = 3

• bool record_partition_graphs = 4

• bool report_tensor_allocations_upon_oom = 5

Used as request type in: grpc.MasterService.ExtendSession

• string session_handle = 1

  REQUIRED: session_handle must be returned by a CreateSession call to the same master service.

• optional GraphDef graph_def = 2

  REQUIRED: The nodes to be added to the session's graph. If any node has the same name as an existing node, the operation will fail with ILLEGAL_ARGUMENT.

• int64 current_graph_version = 3

  REQUIRED: The version number of the graph to be extended. This will be tested against the current server-side version number, and the operation will fail with FAILED_PRECONDITION if they do not match.

TODO(mrry): Return something about the operation?

Used as response type in: grpc.MasterService.ExtendSession

• int64 new_graph_version = 4

  The new version number for the extended graph, to be used in the next call to ExtendSession.

Containers for non-sequential data.

Used in: FeatureList, Features

• oneof kind

  Each feature can be exactly one kind.

  • BytesList bytes_list = 1

  • FloatList float_list = 2

  • Int64List int64_list = 3

Used in: ExampleParserConfiguration

• oneof config

  • FixedLenFeatureProto fixed_len_feature = 1

  • VarLenFeatureProto var_len_feature = 2

Containers for sequential data. A FeatureList contains lists of Features. These may hold zero or more Feature values. FeatureLists are organized into categories by name. The FeatureLists message contains the mapping from name to FeatureList.

Used in: FeatureLists

• repeated Feature feature = 1

Used in: SequenceExample

• map<string, FeatureList> feature_list = 1

  Map from feature name to feature list.

Used in: Example, ExampleWithExtras, SequenceExample

• map<string, Feature> feature = 1

  Map from feature name to feature.

Used in: FeatureConfiguration

• DataType dtype = 1

• optional TensorShapeProto shape = 2

• optional TensorProto default_value = 3

• string values_output_tensor_name = 4

Used in: Feature

• repeated float value = 1

A function can be instantiated when the runtime can bind every attr with a value. When a GraphDef has a call to a function, it must have binding for every attr defined in the signature. TODO(zhifengc): * device spec, etc.

Used in: FunctionDefLibrary

• optional OpDef signature = 1

  The definition of the function's name, arguments, return values, attrs etc.

• map<string, AttrValue> attr = 5

  Attributes specific to this function definition.

• repeated NodeDef node_def = 3

  By convention, "op" in node_def is resolved by consulting with a user-defined library first. If not resolved, "func" is assumed to be a builtin op.

• map<string, string> ret = 4

  A mapping from the output arg names from `signature` to the outputs from `node_def` that should be returned by the function.

A library is a set of named functions.

Used in: GraphDef

• repeated FunctionDef function = 1

• repeated GradientDef gradient = 2

• string model = 1

  e.g. "Tesla K40c"

• string uuid = 2

  Final entry in output of "nvidia-smi -L"

• string bus_id = 3

  e.g. "0000:04:00.0"

Used in: ConfigProto

• double per_process_gpu_memory_fraction = 1

  A value between 0 and 1 that indicates what fraction of the available GPU memory to pre-allocate for each process. 1 means to pre-allocate all of the GPU memory, 0.5 means the process allocates ~50% of the available GPU memory.

• string allocator_type = 2

  The type of GPU allocation strategy to use. Allowed values: "": The empty string (default) uses a system-chosen default which may change over time. "BFC": A "Best-fit with coalescing" algorithm, simplified from a version of dlmalloc.

• int64 deferred_deletion_bytes = 3

  Delay deletion of up to this many bytes to reduce the number of interactions with gpu driver code. If 0, the system chooses a reasonable default (several MBs).

• bool allow_growth = 4

  If true, the allocator does not pre-allocate the entire specified GPU memory region, instead starting small and growing as needed.

• string visible_device_list = 5

  A comma-separated list of GPU ids that determines the 'visible' to 'virtual' mapping of GPU devices. For example, if TensorFlow can see 8 GPU devices in the process, and one wanted to map visible GPU devices 5 and 3 as "/device:GPU:0", and "/device:GPU:1", then one would specify this field as "5,3". This field is similar in spirit to the CUDA_VISIBLE_DEVICES environment variable, except it applies to the visible GPU devices in the process. NOTE: 1. The GPU driver provides the process with the visible GPUs in an order which is not guaranteed to have any correlation to the *physical* GPU id in the machine. This field is used for remapping "visible" to "virtual", which means this operates only after the process starts. Users are required to use vendor specific mechanisms (e.g., CUDA_VISIBLE_DEVICES) to control the physical to visible device mapping prior to invoking TensorFlow. 2. In the code, the ids in this list are also called "CUDA GPU id"s, and the 'virtual' ids of GPU devices (i.e. the ids in the device name "/device:GPU:<id>") are also called "TF GPU id"s. Please refer to third_party/tensorflow/core/common_runtime/gpu/gpu_id.h for more information.

• int32 polling_active_delay_usecs = 6

  In the event polling loop sleep this many microseconds between PollEvents calls, when the queue is not empty. If value is not set or set to 0, gets set to a non-zero default.

• int32 polling_inactive_delay_msecs = 7

  This field is deprecated and ignored.

• bool force_gpu_compatible = 8

  Force all tensors to be gpu_compatible. On a GPU-enabled TensorFlow, enabling this option forces all CPU tensors to be allocated with Cuda pinned memory. Normally, TensorFlow will infer which tensors should be allocated as the pinned memory. But in case where the inference is incomplete, this option can significantly speed up the cross-device memory copy performance as long as it fits the memory. Note that this option is not something that should be enabled by default for unknown or very large models, since all Cuda pinned memory is unpageable, having too much pinned memory might negatively impact the overall host system performance.

• optional GPUOptions.Experimental experimental = 9

Everything inside Experimental is subject to change and is not subject to API stability guarantees in https://www.tensorflow.org/programmers_guide/version_compat.

Used in: GPUOptions

• repeated Experimental.VirtualDevices virtual_devices = 1

  The multi virtual device settings. If empty (not set), it will create single virtual device on each visible GPU, according to the settings in "visible_device_list" above. Otherwise, the number of elements in the list must be the same as the number of visible GPUs (after "visible_device_list" filtering if it is set), and the string represented device names (e.g. /device:GPU:<id>) will refer to the virtual devices and have the <id> field assigned sequentially starting from 0, according to the order they appear in this list and the "memory_limit" list inside each element. For example, visible_device_list = "1,0" virtual_devices { memory_limit: 1GB memory_limit: 2GB } virtual_devices {} will create three virtual devices as: /device:GPU:0 -> visible GPU 1 with 1GB memory /device:GPU:1 -> visible GPU 1 with 2GB memory /device:GPU:2 -> visible GPU 0 with all available memory NOTE: 1. It's invalid to set both this and "per_process_gpu_memory_fraction" at the same time. 2. Currently this setting is per-process, not per-session. Using different settings in different sessions within same process will result in undefined behavior.

Configuration for breaking down a visible GPU into multiple "virtual" devices.

Used in: Experimental

• repeated float memory_limit_mb = 1

  Per "virtual" device memory limit, in MB. The number of elements in the list is the number of virtual devices to create on the corresponding visible GPU (see "virtual_devices" below). If empty, it will create single virtual device taking all available memory from the device. For the concept of "visible" and "virtual" GPU, see the comments for "visible_device_list" above for more information.

Used as request type in: grpc.WorkerService.GetStatus

(message has no fields)

Used as response type in: grpc.WorkerService.GetStatus

• repeated DeviceAttributes device_attributes = 1

GradientDef defines the gradient function of a function defined in a function library. A gradient function g (specified by gradient_func) for a function f (specified by function_name) must follow the following: The function 'f' must be a numerical function which takes N inputs and produces M outputs. Its gradient function 'g', which is a function taking N + M inputs and produces N outputs. I.e. if we have (y1, y2, ..., y_M) = f(x1, x2, ..., x_N), then, g is (dL/dx1, dL/dx2, ..., dL/dx_N) = g(x1, x2, ..., x_N, dL/dy1, dL/dy2, ..., dL/dy_M), where L is a scalar-value function of (x1, x2, ..., xN) (e.g., the loss function). dL/dx_i is the partial derivative of L with respect to x_i.

Used in: FunctionDefLibrary

• string function_name = 1

  The function name.

• string gradient_func = 2

  The gradient function's name.

Represents the graph of operations

Used in: CreateSessionRequest, ExtendSessionRequest, MetaGraphDef, ProfileResponse, RegisterGraphRequest, RemoteFusedGraphExecuteInfo, RunGraphResponse, RunMetadata

• repeated NodeDef node = 1

• optional VersionDef versions = 4

  Compatibility versions of the graph. See core/public/version.h for version history. The GraphDef version is distinct from the TensorFlow version, and each release of TensorFlow will support a range of GraphDef versions.

• int32 version = 3

  Deprecated single version field; use versions above instead. Since all GraphDef changes before "versions" was introduced were forward compatible, this field is entirely ignored.

• optional FunctionDefLibrary library = 2

  EXPERIMENTAL. DO NOT USE OR DEPEND ON THIS YET. "library" provides user-defined functions. Naming: * library.function.name are in a flat namespace. NOTE: We may need to change it to be hierarchical to support different orgs. E.g., { "/google/nn", { ... }}, { "/google/vision", { ... }} { "/org_foo/module_bar", { ... }} map<string, FunctionDefLib> named_lib; * If node[i].op is the name of one function in "library", node[i] is deemed as a function call. Otherwise, node[i].op must be a primitive operation supported by the runtime. Function call semantics: * The callee may start execution as soon as some of its inputs are ready. The caller may want to use Tuple() mechanism to ensure all inputs are ready in the same time. * The consumer of return values may start executing as soon as the return values the consumer depends on are ready. The consumer may want to use Tuple() mechanism to ensure the consumer does not start until all return values of the callee function are ready.

Used in: ConfigProto, RegisterGraphRequest

• bool enable_recv_scheduling = 2

  If true, use control flow to schedule the activation of Recv nodes. (Currently ignored.)

• optional OptimizerOptions optimizer_options = 3

  Options controlling how graph is optimized.

• int64 build_cost_model = 4

  The number of steps to run before returning a cost model detailing the memory usage and performance of each node of the graph. 0 means no cost model.

• int64 build_cost_model_after = 9

  The number of steps to skip before collecting statistics for the cost model.

• bool infer_shapes = 5

  Annotate each Node with Op output shape data, to the extent it can be statically inferred.

• bool place_pruned_graph = 6

  Only place the subgraphs that are run, rather than the entire graph. This is useful for interactive graph building, where one might produce graphs that cannot be placed during the debugging process. In particular, it allows the client to continue work in a session after adding a node to a graph whose placement constraints are unsatisfiable.

• bool enable_bfloat16_sendrecv = 7

  If true, transfer float values between processes as bfloat16.

• int32 timeline_step = 8

  If > 0, record a timeline every this many steps. EXPERIMENTAL: This currently has no effect in MasterSession.

• optional RewriterConfig rewrite_options = 10

  Options that control the type and amount of graph rewriting. Not currently configurable via the public Python API (i.e. there is no API stability guarantee if you import RewriterConfig explicitly).

Protocol buffer representing a handle to a tensorflow resource. Handles are not valid across executions, but can be serialized back and forth from within a single run.

• repeated GraphTransferInfo.NodeInfo node_info = 1

• repeated GraphTransferInfo.ConstNodeInfo const_node_info = 2

• repeated GraphTransferInfo.NodeInputInfo node_input_info = 3

• repeated GraphTransferInfo.NodeOutputInfo node_output_info = 4

• repeated GraphTransferInfo.GraphInputNodeInfo graph_input_node_info = 5

  Input Node parameters of transferred graph

• repeated GraphTransferInfo.GraphOutputNodeInfo graph_output_node_info = 6

• GraphTransferInfo.Destination destination = 7

  Destination of graph transfer

Used in: GraphTransferInfo

• string name = 1

• int32 node_id = 2

• repeated int64 shape = 3

• bytes data = 4

• DataType dtype = 5

Used in: GraphTransferInfo

• NOP = 0

• HEXAGON = 1

Used in: GraphTransferInfo

• string name = 1

• repeated int64 shape = 2

• DataType dtype = 3

Used in: GraphTransferInfo

• string name = 1

• repeated int64 shape = 2

• DataType dtype = 3

Used in: GraphTransferInfo

• string name = 1

• int32 node_id = 2

• string type_name = 3

• int32 soc_op_id = 4

• int32 padding_id = 5

• int32 input_count = 6

• int32 output_count = 7

Used in: NodeInputInfo

• int32 node_id = 1

• int32 output_port = 2

Used in: GraphTransferInfo

• int32 node_id = 1

• repeated NodeInput node_input = 2

Used in: GraphTransferInfo

• int32 node_id = 1

• repeated int32 max_byte_size = 2

Protocol buffer holding hyper parameters. Examples of hyper parameters: learning_rate = 0.1, num_hidden_units = 100, activations = ['relu', 'tanh']

• map<string, HParamDef.HParamType> hparam = 1

Used in: HParamType

• repeated bool value = 1

Used in: HParamType

• repeated bytes value = 1

Used in: HParamType

• repeated float value = 1

Used in: HParamDef

• oneof kind

  • int64 int64_value = 1

  • float float_value = 2

  • bytes bytes_value = 3

  • bool bool_value = 7

  • Int64List int64_list = 4

  • FloatList float_list = 5

  • BytesList bytes_list = 6

  • BoolList bool_list = 8

Used in: HParamType

• repeated int64 value = 1

Serialization format for histogram module in core/lib/histogram/histogram.h

Used in: Summary.Value

• double min = 1

• double max = 2

• double num = 3

• double sum = 4

• double sum_squares = 5

• repeated double bucket_limit = 6

  Parallel arrays encoding the bucket boundaries and the bucket values. bucket(i) is the count for the bucket i. The range for a bucket is: i == 0: -DBL_MAX .. bucket_limit(0) i != 0: bucket_limit(i-1) .. bucket_limit(i)

• repeated double bucket = 7

Used in: Feature

• repeated int64 value = 1

Used in: LocalLinks

• int32 device_id = 1

• string type = 2

• int32 strength = 3

Protocol buffer representing the metadata for an iterator's state stored as a Variant tensor.

• string version = 1

  A user-specified version string.

• repeated string keys = 2

  Keys for tensors in the VariantTensorDataProto.

Defines a single job in a TensorFlow cluster.

Used in: ClusterDef

• string name = 1

  The name of this job.

• map<int32, string> tasks = 2

  Mapping from task ID to "hostname:port" string. If the `name` field contains "worker", and the `tasks` map contains a mapping from 7 to "example.org:2222", then the device prefix "/job:worker/task:7" will be assigned to "example.org:2222".

• string op = 1

  Must match the name of an Op.

• string device_type = 2

  Type of device this kernel runs on.

• repeated KernelDef.AttrConstraint constraint = 3

• repeated string host_memory_arg = 4

  Names of the Op's input_/output_args that reside in host memory instead of device memory.

• string label = 5

  This allows experimental kernels to be registered for an op that won't be used unless the user specifies a "_kernel" attr with value matching this.

Used in: KernelDef

• string name = 1

  Name of an attr from the Op.

• optional AttrValue allowed_values = 2

  A list of values that this kernel supports for this attr. Like OpDef.AttrDef.allowed_values, except for kernels instead of Ops.

Used in: LoggingResponse

• int64 step_id = 1

• optional StepStats step_stats = 2

Used as request type in: grpc.MasterService.ListDevices

• string session_handle = 1

  Optional: session_handle must be returned by a CreateSession call to the same master service. When session_handle is empty, the ClusterSpec provided when the master was started is used to compute the available devices. If the session_handle is provided but not recognized, an error is returned. Finally, if a valid session_handle is provided, the cluster configuration for that session is used when computing the response.

Used as response type in: grpc.MasterService.ListDevices

• repeated DeviceAttributes local_device = 1

• repeated DeviceAttributes remote_device = 2

Used in: DeviceLocality

• repeated InterconnectLink link = 1

Protocol buffer used for logging messages to the events file.

Used in: Event

• LogMessage.Level level = 1

• string message = 2

Used in: LogMessage

• UNKNOWN = 0

• DEBUGGING = 10

  Note: The logging level 10 cannot be named DEBUG. Some software projects compile their C/C++ code with -DDEBUG in debug builds. So the C++ code generated from this file should not have an identifier named DEBUG.

• INFO = 20

• WARN = 30

• ERROR = 40

• FATAL = 50

Used in: OpPerformance

• double mu = 1

• double sigma = 2

Out-of-band request to begin or end logging, or to retrieve logs for particular steps.

Used as request type in: grpc.WorkerService.Logging

• bool rpc_logging = 1

  If true, RPC logging will be activated.

• bool clear = 2

  If true, discard any saved logging data (for all steps).

• repeated int64 fetch_step_id = 3

  When set, requests all saved log data pertaining to the step. Any log data retrieved is eliminated from the store and cannot be retrieved again.

Used as response type in: grpc.WorkerService.Logging

• repeated LabeledStepStats step = 1

• optional RecvTensorResponse response = 1

• bool singleSend = 2

• string key = 3

• int64 step_id = 4

• uint64 checksum = 5

Used in: TestResults

• string hostname = 1

  Host name of machine that ran the benchmark.

• string serial_identifier = 7

  Unique serial number of the machine.

• optional PlatformInfo platform_info = 2

  Additional platform information.

• optional CPUInfo cpu_info = 3

  CPU Information.

• repeated google.protobuf.Any device_info = 4

  Other devices that are attached and relevant (e.g. GPUInfo).

• repeated AvailableDeviceInfo available_device_info = 5

  Devices accessible to the test (e.g. as given by list_local_devices).

• optional MemoryInfo memory_info = 6

Used as request type in: grpc.MasterService.MakeCallable

• string session_handle = 1

  REQUIRED: session_handle must be returned by a CreateSession call to the same master service.

• optional CallableOptions options = 2

  Options that define the behavior of the created callable.

Used as response type in: grpc.MasterService.MakeCallable

• int64 handle = 1

  A handle to the created callable.

A directory of regions in a memmapped file.

• repeated MemmappedFileSystemDirectoryElement element = 1

A message that describes one region of memmapped file.

Used in: MemmappedFileSystemDirectory

• uint64 offset = 1

• string name = 2

Used in: MachineConfiguration

• int64 total = 1

  Total virtual memory in bytes

• int64 available = 2

  Immediately available memory in bytes

• int64 step_id = 1

  Process-unique step id.

• string operation = 2

  Name of the operation making the allocation.

• int64 num_bytes = 3

  Number of bytes in the allocation.

• uint64 ptr = 4

  Address of the allocation.

• int64 allocation_id = 5

  Id of the tensor buffer being allocated, used to match to a corresponding deallocation.

• string allocator_name = 6

  Name of the allocator used.

• int64 step_id = 1

  Process-unique step id.

• string operation = 2

  Name of the operation making the deallocation.

• int64 allocation_id = 3

  Id of the tensor buffer being deallocated, used to match to a corresponding allocation.

• string allocator_name = 4

  Name of the allocator used.

• bool deferred = 5

  True if the deallocation is queued and will be performed later, e.g. for GPU lazy freeing of buffers.

• int64 step_id = 1

  Process-unique step id.

• string handle = 2

  Handle describing the feeds and fetches of the step.

• int64 step_id = 1

  Process-unique step id.

• string kernel_name = 2

  Name of the kernel making the allocation as set in GraphDef, e.g., "affine2/weights/Assign".

• optional TensorDescription tensor = 3

  Allocated tensor details.

• int64 allocation_id = 1

  Id of the tensor buffer being deallocated, used to match to a corresponding allocation.

• string allocator_name = 2

  Name of the allocator used.

• int64 step_id = 1

  Process-unique step id.

• string kernel_name = 2

  Name of the kernel producing an output as set in GraphDef, e.g., "affine2/weights/Assign".

• int32 index = 3

  Index of the output being set.

• optional TensorDescription tensor = 4

  Output tensor details.

Used in: GetRemoteAddressRequest, GetRemoteAddressResponse

• uint64 remote_addr = 1

• uint32 rkey = 2

For memory tracking.

Used in: NodeExecStats

• int64 temp_memory_size = 1

• int64 persistent_memory_size = 3

• repeated int64 persistent_tensor_alloc_ids = 5

• int64 device_temp_memory_size = 2

• int64 device_persistent_memory_size = 4

• repeated int64 device_persistent_tensor_alloc_ids = 6

NOTE: This protocol buffer is evolving, and will go through revisions in the coming months. Protocol buffer containing the following which are necessary to restart training, run inference. It can be used to serialize/de-serialize memory objects necessary for running computation in a graph when crossing the process boundary. It can be used for long term storage of graphs, cross-language execution of graphs, etc. MetaInfoDef GraphDef SaverDef CollectionDef TensorInfo SignatureDef

Used in: SavedModel

• optional MetaGraphDef.MetaInfoDef meta_info_def = 1

• optional GraphDef graph_def = 2

  GraphDef.

• optional SaverDef saver_def = 3

  SaverDef.

• map<string, CollectionDef> collection_def = 4

  collection_def: Map from collection name to collections. See CollectionDef section for details.

• map<string, SignatureDef> signature_def = 5

  signature_def: Map from user supplied key for a signature to a single SignatureDef.

• repeated AssetFileDef asset_file_def = 6

  Asset file def to be used with the defined graph.

Meta information regarding the graph to be exported. To be used by users of this protocol buffer to encode information regarding their meta graph.

Used in: MetaGraphDef

• string meta_graph_version = 1

  User specified Version string. Can be the name of the model and revision, steps this model has been trained to, etc.

• optional OpList stripped_op_list = 2

  A copy of the OpDefs used by the producer of this graph_def. Descriptions and Ops not used in graph_def are stripped out.

• optional google.protobuf.Any any_info = 3

  A serialized protobuf. Can be the time this meta graph is created, or modified, or name of the model.

• repeated string tags = 4

  User supplied tag(s) on the meta_graph and included graph_def. MetaGraphDefs should be tagged with their capabilities or use-cases. Examples: "train", "serve", "gpu", "tpu", etc. These tags enable loaders to access the MetaGraph(s) appropriate for a specific use-case or runtime environment.

• string tensorflow_version = 5

  The __version__ string of the tensorflow build used to write this graph. This will be populated by the framework, which will overwrite any user supplied value.

• string tensorflow_git_version = 6

  The __git_version__ string of the tensorflow build used to write this graph. This will be populated by the framework, which will overwrite any user supplied value.

• bool stripped_default_attrs = 7

  A flag to denote whether default-valued attrs have been stripped from the nodes in this graph_def.

A list of attr names and their values. The whole list is attached with a string name. E.g., MatMul[T=float].

Used in: AttrValue, AttrValue.ListValue

• string name = 1

• map<string, AttrValue> attr = 2

• string name = 1

• optional DeviceProperties properties = 2

A pair of tensor name and tensor values.

Used in: RunGraphRequest, RunGraphResponse, RunStepRequest, RunStepResponse

• string name = 1

  Name of the tensor.

• optional TensorProto tensor = 2

  The client can populate a TensorProto using a tensorflow::Tensor`, or directly using the protobuf field accessors. The client specifies whether the returned tensor values should be filled tensor fields (float_val, int_val, etc.) or encoded in a compact form in tensor.tensor_content.

Used in: FunctionDef, GraphDef

• string name = 1

  The name given to this operator. Used for naming inputs, logging, visualization, etc. Unique within a single GraphDef. Must match the regexp "[A-Za-z0-9.][A-Za-z0-9_./]*".

• string op = 2

  The operation name. There may be custom parameters in attrs. Op names starting with an underscore are reserved for internal use.

• repeated string input = 3

  Each input is "node:src_output" with "node" being a string name and "src_output" indicating which output tensor to use from "node". If "src_output" is 0 the ":0" suffix can be omitted. Regular inputs may optionally be followed by control inputs that have the format "^node".

• string device = 4

  A (possibly partial) specification for the device on which this node should be placed. The expected syntax for this string is as follows: DEVICE_SPEC ::= PARTIAL_SPEC PARTIAL_SPEC ::= ("/" CONSTRAINT) * CONSTRAINT ::= ("job:" JOB_NAME) | ("replica:" [1-9][0-9]*) | ("task:" [1-9][0-9]*) | ("device:" [A-Za-z]* ":" ([1-9][0-9]* | "*") ) Valid values for this string include: * "/job:worker/replica:0/task:1/device:GPU:3" (full specification) * "/job:worker/device:GPU:3" (partial specification) * "" (no specification) If the constraints do not resolve to a single device (or if this field is empty or not present), the runtime will attempt to choose a device automatically.

• map<string, AttrValue> attr = 5

  Operation-specific graph-construction-time configuration. Note that this should include all attrs defined in the corresponding OpDef, including those with a value matching the default -- this allows the default to change and makes NodeDefs easier to interpret on their own. However, if an attr with a default is not specified in this list, the default will be used. The "names" (keys) must match the regexp "[a-z][a-z0-9_]+" (and one of the names from the corresponding OpDef's attr field). The values must have a type matching the corresponding OpDef attr's type field. TODO(josh11b): Add some examples here showing best practices.

Time/size stats recorded for a single execution of a graph node.

Used in: DeviceStepStats

• string node_name = 1

  TODO(tucker): Use some more compact form of node identity than the full string name. Either all processes should agree on a global id (cost_id?) for each node, or we should use a hash of the name.

• int64 all_start_micros = 2

• int64 op_start_rel_micros = 3

• int64 op_end_rel_micros = 4

• int64 all_end_rel_micros = 5

• repeated AllocatorMemoryUsed memory = 6

• repeated NodeOutput output = 7

• string timeline_label = 8

• int64 scheduled_micros = 9

• uint32 thread_id = 10

• repeated AllocationDescription referenced_tensor = 11

• optional MemoryStats memory_stats = 12

Output sizes recorded for a single execution of a graph node.

Used in: NodeExecStats

• int32 slot = 1

• optional TensorDescription tensor_description = 3

Used in: OpPerformance

• double mu = 1

• double sigma = 2

Defines an operation. A NodeDef in a GraphDef specifies an Op by using the "op" field which should match the name of a OpDef. LINT.IfChange

Used in: FunctionDef, OpList

• string name = 1

  Op names starting with an underscore are reserved for internal use. Names should be CamelCase and match the regexp "[A-Z][a-zA-Z0-9_]*".

• repeated OpDef.ArgDef input_arg = 2

  Description of the input(s).

• repeated OpDef.ArgDef output_arg = 3

  Description of the output(s).

• repeated OpDef.AttrDef attr = 4

• optional OpDeprecation deprecation = 8

  Optional deprecation based on GraphDef versions.

• string summary = 5

  One-line human-readable description of what the Op does.

• string description = 6

  Additional, longer human-readable description of what the Op does.

• bool is_commutative = 18

  True if the operation is commutative ("op(a,b) == op(b,a)" for all inputs)

• bool is_aggregate = 16

  If is_aggregate is true, then this operation accepts N >= 2 inputs and produces 1 output all of the same type. Should be associative and commutative, and produce output with the same shape as the input. The optimizer may replace an aggregate op taking input from multiple devices with a tree of aggregate ops that aggregate locally within each device (and possibly within groups of nearby devices) before communicating. TODO(josh11b): Implement that optimization.

  for things like add

• bool is_stateful = 17

  Ops are marked as stateful if their behavior depends on some state beyond their input tensors (e.g. variable reading op) or if they have a side-effect (e.g. printing or asserting ops). Equivalently, stateless ops must always produce the same output for the same input and have no side-effects. By default Ops may be moved between devices. Stateful ops should either not be moved, or should only be moved if that state can also be moved (e.g. via some sort of save / restore). Stateful ops are guaranteed to never be optimized away by Common Subexpression Elimination (CSE).

  for things like variables, queue

• bool allows_uninitialized_input = 19

  By default, all inputs to an Op must be initialized Tensors. Ops that may initialize tensors for the first time should set this field to true, to allow the Op to take an uninitialized Tensor as input.

  for Assign, etc.

For describing inputs and outputs.

Used in: OpDef

• string name = 1

  Name for the input/output. Should match the regexp "[a-z][a-z0-9_]*".

• string description = 2

  Human readable description.

• DataType type = 3

  Describes the type of one or more tensors that are accepted/produced by this input/output arg. The only legal combinations are: * For a single tensor: either the "type" field is set or the "type_attr" field is set to the name of an attr with type "type". * For a sequence of tensors with the same type: the "number_attr" field will be set to the name of an attr with type "int", and either the "type" or "type_attr" field will be set as for single tensors. * For a sequence of tensors, the "type_list_attr" field will be set to the name of an attr with type "list(type)".

• string type_attr = 4

  if specified, attr must have type "type"

• string number_attr = 5

  if specified, attr must have type "int"

• string type_list_attr = 6

  If specified, attr must have type "list(type)", and none of type, type_attr, and number_attr may be specified.

• bool is_ref = 16

  For inputs: if true, the inputs are required to be refs. By default, inputs can be either refs or non-refs. For outputs: if true, outputs are refs, otherwise they are not.

Description of the graph-construction-time configuration of this Op. That is to say, this describes the attr fields that will be specified in the NodeDef.

Used in: OpDef

• string name = 1

  A descriptive name for the argument. May be used, e.g. by the Python client, as a keyword argument name, and so should match the regexp "[a-z][a-z0-9_]+".

• string type = 2

  One of the type names from attr_value.proto ("string", "list(string)", "int", etc.).

• optional AttrValue default_value = 3

  A reasonable default for this attribute if the user does not supply a value. If not specified, the user must supply a value.

• string description = 4

  Human-readable description.

• bool has_minimum = 5

  For type == "int", this is a minimum value. For "list(___)" types, this is the minimum length.

• int64 minimum = 6

• optional AttrValue allowed_values = 7

  The set of allowed values. Has type that is the "list" version of the "type" field above (uses the "list" field of AttrValue). If type == "type" or "list(type)" above, then the "type" field of "allowed_values.list" has the set of allowed DataTypes. If type == "string" or "list(string)", then the "s" field of "allowed_values.list" has the set of allowed strings.

Information about version-dependent deprecation of an op

Used in: OpDef

• int32 version = 1

  First GraphDef version at which the op is disallowed.

• string explanation = 2

  Explanation of why it was deprecated and what to use instead.

Description of an operation as well as the parameters expected to impact its performance.

Used in: OpPerformance

• string op = 1

  The operation name. There may be custom parameters in attrs.

• map<string, AttrValue> attr = 2

  Custom parameters impacting the behavior of the op.

• repeated OpInfo.TensorProperties inputs = 3

• repeated OpInfo.TensorProperties outputs = 5

  Optional description of the op outputs

• optional DeviceProperties device = 4

  Device on which the operation is run.

• optional SessionInfo session_info = 6

  Information about the session configs.

Input data types, shapes and values if known.

Used in: OpInfo

• DataType dtype = 1

• optional TensorShapeProto shape = 2

• optional TensorProto value = 3

A collection of OpDefs

Used in: MetaGraphDef.MetaInfoDef

• repeated OpDef op = 1

Performance data for tensorflow operations

Used in: OpPerformanceList

• optional OpInfo op = 1

  The op

• optional SessionInfo session_info = 12

  Information about the session configs.

• string node = 5

  The node name (optional). Makes it easier to associate the performance data with a specific graph node.

• int64 temporary_memory_size = 2

  Temporary memory used by this node (in bytes).

• int64 compute_cost = 3

  Time it takes to run the op (in nanoseconds).

• int64 compute_time = 6

  Analytical compute cost (in nanoseconds).

• int64 memory_time = 7

  Analytical memory access cost (in nanoseconds).

• double compute_efficiency = 4

  Percentage of theoretical compute performance.

• double memory_efficiency = 8

  Percentage of theoretical memory performance.

• oneof execution_time

  Expected execution time, modeled using one of 2 possible distributions.

  • NormalDistribution execution_time_normal = 10

  • LogNormalDistribution execution_time_log_normal = 11

• optional OpPerformance.OpMemory op_memory = 9

Memory usage data for a tensorflow operation.

Used in: OpPerformance

• repeated int64 output_memory = 1

  The output information may have memory usage and output shapes.

• int64 temp_memory = 2

  Temp and persistent memory allocated by this node.

• int64 persistent_memory = 4

• int64 device_temp_memory = 3

• int64 device_persistent_memory = 5

A collection of OpPerformance data points.

• repeated OpPerformance op_performance = 1

Options passed to the graph optimizer

Used in: GraphOptions

• bool do_common_subexpression_elimination = 1

  If true, optimize the graph using common subexpression elimination.

• bool do_constant_folding = 2

  If true, perform constant folding optimization on the graph.

• int64 max_folded_constant_in_bytes = 6

  Constant folding optimization replaces tensors whose values can be predetermined, with constant nodes. To avoid inserting too large constants, the size of each constant created can be limited. If this value is zero, a default limit of 10 MiB will be applied. If constant folding optimization is disabled, this value is ignored.

• bool do_function_inlining = 4

  If true, perform function inlining on the graph.

• OptimizerOptions.Level opt_level = 3

  Overall optimization level. The actual optimizations applied will be the logical OR of the flags that this level implies and any flags already set.

• OptimizerOptions.GlobalJitLevel global_jit_level = 5

Control the use of the compiler/jit. Experimental.

Used in: OptimizerOptions

• DEFAULT = 0

  Default setting ("off" now, but later expected to be "on")

• OFF = -1

• ON_1 = 1

  The following settings turn on compilation, with higher values being more aggressive. Higher values may reduce opportunities for parallelism and may use more memory. (At present, there is no distinction, but this is expected to change.)

• ON_2 = 2

Optimization level

Used in: OptimizerOptions

• L1 = 0

  L1 is the default level. Optimization performed at L1 : 1. Common subexpression elimination 2. Constant folding

• L0 = -1

  No optimizations

Used as request type in: grpc.MasterService.PartialRunSetup

• string session_handle = 1

  REQUIRED: session_handle must be returned by a CreateSession call to the same master service.

• repeated string feed = 2

  Tensors to be fed in future steps.

• repeated string fetch = 3

  Fetches. A list of tensor names. The caller expects a tensor to be returned for each fetch[i] (see RunStepResponse.tensor), for corresponding partial RunStepRequests. The order of specified fetches does not change the execution order.

• repeated string target = 4

  Target Nodes. A list of node names. The named nodes will be run in future steps, but their outputs will not be fetched.

Used as response type in: grpc.MasterService.PartialRunSetup

• string partial_run_handle = 1

  The unique handle corresponding to the ongoing partial run call setup by the invocation to PartialRunSetup. This handle may be passed to RunStepRequest to send and receive tensors for this partial run.

Used in: MachineConfiguration

• string bits = 1

  e.g. '64bit'

• string linkage = 2

  e.g. 'ELF'

• string machine = 3

  e.g. 'i386'

• string release = 4

  e.g. '3.13.0-76-generic'

• string system = 5

  e.g. 'Linux'

• string version = 6

  e.g. '#120-Ubuntu SMP Mon Jan 18 15:59:10 UTC 2016'

Used in: ProfileRequest

• bool include_dataset_ops = 1

  We don't collect the dataset ops by default for better trace-viewer scalability. The caller can mannually set this field to include the ops.

Used as request type in: TPUProfiler.Profile

Used as field type in: NewProfileSessionRequest

• uint64 duration_ms = 1

  In future, the caller will be able to customize when profiling starts and stops. For now, it collects `duration_ms` milliseconds worth of data.

• uint64 max_events = 2

  The maximum number of events to return. By default (value 0), return all events.

• repeated string tools = 3

  Required profiling tools name such as "input_pipeline_analyzer" etc

• map<string, ToolRequestOptions> tool_options = 8

  Specifies the requirement for each tools.

• optional ProfileOptions opts = 4

  Optional profiling options that control how a TF session will be profiled.

• string repository_root = 5

  The place where we will dump profile data. We will normally use MODEL_DIR/plugin/profile/ as our repository root.

• string session_id = 6

  The user provided profile session identifier.

• string host_name = 7

  The hostname of system where the profile should happen. We use it as identifier in part of our output filename.

Used in: EnumProfileSessionsAndToolsResponse

• string session_id = 1

• repeated string available_tools = 2

  Which tool data is available for consumption.

Used in: ProfileResponse

• string name = 1

  The tool's name which this data is associated. (e.g. "input_pipeline".)

• bytes data = 2

  The data payload (likely json) for the specific tool.

• string model_checkpoint_path = 1

  Path to the checkpoint file. Use either this or model_checkpoint_dir.

• repeated EmbeddingInfo embeddings = 2

• string model_checkpoint_dir = 3

  Path to the checkpoint directory. The directory will be scanned for the latest checkpoint file.

Protocol buffer representing a QueueRunner.

• string queue_name = 1

  Queue name.

• repeated string enqueue_op_name = 2

  A list of enqueue operations.

• string close_op_name = 3

  The operation to run to close the queue.

• string cancel_op_name = 4

  The operation to run to cancel the queue.

• repeated error.Code queue_closed_exception_types = 5

  A list of exception types considered to signal a safely closed queue if raised during enqueue operations.

Used in: ConfigProto

• bool use_rpc_for_inprocess_master = 1

  If true, always use RPC to contact the session target. If false (the default option), TensorFlow may use an optimized transport for client-master communication that avoids the RPC stack. This option is primarily for used testing the RPC stack.

For serializing and restoring the state of ReaderBase, see reader_base.h for details.

• int64 work_started = 1

• int64 work_finished = 2

• int64 num_records_produced = 3

• bytes current_work = 4

Used as request type in: grpc.WorkerService.RecvTensor

• int64 step_id = 1

  The step in which the tensor will be produced. REQUIRED: This must eventually correspond to the `step_id` passed into a RunGraph call on the same WorkerService.

• string rendezvous_key = 2

  A key identifying the channel to receive tensors from. A RecvTensor request retrieves one tensor from the channel, but multiple tensors can be sent and received over the same channel with multiple RecvTensor requests. See rendezvous.h for details.

• bool dma_ok = 3

  If true, use an out-of-band DMA mechanism to transfer the received tensor.

• optional DeviceLocality client_locality = 4

  Optional information on client-side device locality.

• optional DeviceLocality server_locality = 5

  Optional information on server-side device locality.

• optional google.protobuf.Any transport_options = 6

  Optional information needed by the RPC subsystem.

• int64 request_id = 7

  Unique identifier for this request. Every RecvTensorRequest must have a unique request_id, and retried RecvTensorRequests must have the same request_id. If request_id is zero, retry detection is disabled. Retried RecvTensorRequests are problematic because a RecvTensor with no corresponding sender will wait forever, and the tensor may have been delivered to a previous retry. Workers use request_ids to reject retried RecvTensor requests instead of waiting forever.

Used as response type in: grpc.WorkerService.RecvTensor

Used as field type in: MPIRecvTensorResponse

• optional TensorProto tensor = 1

  The tensor as a proto.

• bool is_dead = 2

  If true, this tensor was the output of a dead node, and the content is invalid.

• int64 send_start_micros = 3

  The time at which tensor was available and started to be returned.

• optional google.protobuf.Any transport_options = 4

  Optional additional information about how to receive the tensor, e.g. in the event that `RecvTensorRequest.dma_ok` was true.

Used as request type in: grpc.WorkerService.RegisterGraph

• string session_handle = 1

  Subgraphs are scoped within one session.

• optional GraphDef graph_def = 2

  "graph_def" has the subgraph of nodes for this worker, with each node having its device_name filled in.

• bool has_control_flow = 3

  True iff the graph (before partitioning) contains control flow nodes. As of 01/11/2015, this is no longer set by clients.

• optional GraphOptions graph_options = 4

  Configuration options for the session in which this graph was created.

• optional DebugOptions debug_options = 5

  Field(s) used by TensorFlow Debugger (tfdbg).

Used as response type in: grpc.WorkerService.RegisterGraph

• string graph_handle = 1

  If the registration succeeds, returns an opaque graph_handle to the master. The master calls RunGraph with graph_handle to compute different steps.

Used as request type in: grpc.MasterService.ReleaseCallable

• string session_handle = 1

  REQUIRED: session_handle must be returned by a CreateSession call to the same master service.

• int64 handle = 2

  REQUIRED: handle must be returned by a MakeCallable call to the same master service.

Used as response type in: grpc.MasterService.ReleaseCallable

(message has no fields)

Protocol buffer representing a handle to a tensorflow resource. Handles are not valid across executions, but can be serialized back and forth from within a single run.

• optional GraphDef remote_graph = 1

  Definition of remote graph

• repeated string graph_input_node_name = 2

  Remote fused graph input node name

• repeated string graph_output_node_name = 3

  Remote fused graph output node name

• string executor_name = 4

  Executor's name

• bytes serialized_executor_parameters = 5

  Optional: Parameters given to the executor

• repeated RemoteFusedGraphExecuteInfo.TensorShapeTypeProto default_graph_input_tensor_shape = 6

  Optional: Default graph input tensor shape used to allocate memory before executing op

• repeated RemoteFusedGraphExecuteInfo.TensorShapeTypeProto default_graph_output_tensor_shape = 7

  Optional: Default graph input tensor shape used to allocate memory before executing op TODO(satok): Remote output tensor shape once shape information is stored in NodeDef

• UNUSED = 0

• GRAPH_INPUT = 1

• GRAPH_OUTPUT = 2

• FUSED_NODE = 3

• BORDER_INPUT = 4

• BORDER_OUTPUT = 5

Used in: RemoteFusedGraphExecuteInfo

• DataType dtype = 1

• optional TensorShapeProto shape = 2

• string host = 1

• string port = 2

• uint64 addr = 3

• uint32 rkey = 4

• uint32 tensor_key = 5

• uint64 checksum = 6

Reset() allows misbehaving or slow sessions to be aborted and closed, and causes their resources eventually to be released. Reset() does not wait for the computations in old sessions to cease; it merely starts the process of tearing them down. However, if a new session is started after a Reset(), the new session is isolated from changes that old sessions (started prior to the Reset()) may continue to make to resources, provided all those resources are in containers listed in "containers". Old sessions may continue to have side-effects on resources not in containers listed in "containers", and thus may affect future sessions' results in ways that are hard to predict. Thus, if well-defined behavior is desired, is it recommended that all containers be listed in "containers". Similarly, if a device_filter is specified, results may be hard to predict.

Used as request type in: grpc.MasterService.Reset

• repeated string container = 1

  A list of container names, which may be empty. If 'container' is not empty, releases resoures in the given containers in all devices. If 'container' is empty, releases resources in the default container in all devices.

• repeated string device_filters = 2

  When any filters are present, only devices that match the filters will be reset. Each filter can be partially specified, e.g. "/job:ps" "/job:worker/replica:3", etc.

Used as response type in: grpc.MasterService.Reset

(message has no fields)

Protocol buffer representing a handle to a tensorflow resource. Handles are not valid across executions, but can be serialized back and forth from within a single run.

Used in: TensorProto

• string device = 1

  Unique name for the device containing the resource.

• string container = 2

  Container in which this resource is placed.

• string name = 3

  Unique name of this resource.

• uint64 hash_code = 4

  Hash code for the type of the resource. Is only valid in the same device and in the same execution.

• string maybe_type_name = 5

  For debug-only, the name of the type pointed to by this handle, if available.

Graph rewriting is experimental and subject to change, not covered by any API stability guarantees.

Used in: GraphOptions

• RewriterConfig.Toggle layout_optimizer = 1

  Optimize tensor layouts (default is ON) e.g. This will try to use NCHW layout on GPU which is faster.

• RewriterConfig.Toggle constant_folding = 3

  Fold constants (default is ON) Statically infer the value of tensors when possible, and materialize the result using constants.

• RewriterConfig.Toggle arithmetic_optimization = 7

  Arithmetic optimizations (default is ON) e.g. Simplify arithmetic ops; merge ops with same value (like constants).

• RewriterConfig.Toggle dependency_optimization = 8

  Control dependency optimizations (default is ON). Remove redundant control dependencies, which may enable other optimization.

• RewriterConfig.Toggle loop_optimization = 9

  Loop optimizations (default is ON).

• RewriterConfig.Toggle function_optimization = 10

  Function optimizations (default is ON).

• RewriterConfig.Toggle debug_stripper = 11

  Strips debug-related nodes from the graph (off by default).

• bool disable_model_pruning = 2

  If true, don't remove unnecessary ops from the graph

• RewriterConfig.NumIterationsType meta_optimizer_iterations = 12

  Controls how many times we run the optimizers in meta optimizer (default is once).

• RewriterConfig.MemOptType memory_optimization = 4

  Configures memory optimization passes through the meta-optimizer. Has no effect on manually requested memory optimization passes in the optimizers field.

• string memory_optimizer_target_node_name_scope = 6

  A node name scope for node names which are valid outputs of recompuations. Inputs to nodes that match this scope may be recomputed (subject either to manual annotation of those input nodes or to manual annotation and heuristics depending on memory_optimization), but the nodes themselves will not be recomputed. This matches any sub-scopes as well, meaning the scope can appear not just as a top-level scope. For example, if the value is "gradients/", the default, it will match node name "gradients/foo", "foo/gradients/bar", but not "foo_gradients/"

• optional AutoParallelOptions auto_parallel = 5

  Configures AutoParallel optimization passes either through the meta-optimizer or when manually specified through the optimizers field.

• repeated string optimizers = 100

  If non-empty, will use this as an alternative way to specify a list of optimizations to turn on and the order of the optimizations (replacing the meta-optimizer). Of the RewriterConfig options, only the AutoParallel configuration options (the auto_parallel field) apply to manually requested optimization passes ("autoparallel"). Memory optimization passes ("memory") invoked here are not configurable (in contrast to memory optimization passes through the meta-optimizer) and act only on manual op annotations. Custom registered optimizers will be run after the base optimizers, in the order that they are specified.

Used in: RewriterConfig

• DEFAULT_MEM_OPT = 0

  The default setting (SCHEDULING and SWAPPING HEURISTICS only)

• NO_MEM_OPT = 1

  Disabled in the meta-optimizer.

• MANUAL = 2

  Driven by manual op-level annotations.

• SWAPPING_HEURISTICS = 4

  Swapping heuristic will move a tensor from the GPU to the CPU and move it back when needed to reduce peak memory usage.

• RECOMPUTATION_HEURISTICS = 5

  Recomputation heuristics will recompute ops (such as Relu activation) during backprop instead of storing them, reducing peak memory usage.

• SCHEDULING_HEURISTICS = 6

  Scheduling will split big ops such as AddN and try to enforce a schedule of the new computations that decreases peak memory usage.

• HEURISTICS = 3

  Use any combination of swapping and recomputation heuristics.

Enum controling the number of times to run optimizers. The default is to run them once.

Used in: RewriterConfig

• DEFAULT_NUM_ITERS = 0

• ONE = 1

• TWO = 2

Used in: RewriterConfig

• DEFAULT = 0

• ON = 1

• OFF = 2

• AGGRESSIVE = 3

  Enable some aggressive optimizations that use assumptions that TF graphs may break. For example, assume the shape of a placeholder matches its actual feed.

Used as request type in: grpc.MasterService.RunCallable

• string session_handle = 1

  REQUIRED: session_handle must be returned by a CreateSession call to the same master service.

• int64 handle = 2

  REQUIRED: handle must be returned by a MakeCallable call to the same master service.

• repeated TensorProto feed = 3

  Values of the tensors passed as arguments to the callable, in the order defined in the CallableOptions.feed field passed to MakeCallable.

Used as response type in: grpc.MasterService.RunCallable

• repeated TensorProto fetch = 1

  Values of the tensors returned by the callable, in the order defined in the CallableOptions.fetch field passed to MakeCallable.

• optional RunMetadata metadata = 2

  Returned metadata if requested in the options.

Run-specific items such as arguments to the test / benchmark.

Used in: TestResults

• repeated string argument = 1

Used as request type in: grpc.WorkerService.RunGraph

• string session_handle = 8

  session_handle is the master-generated unique id for this session. If session_handle is non-empty, it must be the same as used when registering the graph. If it is empty, a single global namespace is used to search for the graph_handle.

• string graph_handle = 1

  REQUIRED: graph_handle must be returned by a RegisterGraph call to the same WorkerService.

• int64 step_id = 2

  A unique ID to distinguish different runs of the same graph. The master generates a global unique `step_id` to distinguish different runs of the graph computation. Subgraphs communicate (e.g., send/recv ops) with each other using `step_id` to distinguish tensors generated by different runs.

• optional ExecutorOpts exec_opts = 5

  Options for this step.

• repeated NamedTensorProto send = 3

  Runs the graph. Sends the tensors in "send" into the graph before the run and fetches the keys into `RunGraphResponse.recv` after the run.

• repeated string recv_key = 4

• bool is_partial = 6

  True if the RunGraphRequest is a partial run request.

• bool is_last_partial_run = 7

  True if this is the last partial run request in a sequence of requests.

• bool store_errors_in_response_body = 9

  If true then some errors, e.g., execution errors that have long error messages, may return an OK RunGraphResponse with the actual error saved in the status_code/status_error_message fields of the response body. This is a workaround since the RPC subsystem may truncate long metadata messages.

Used as response type in: grpc.WorkerService.RunGraph

• repeated NamedTensorProto recv = 1

  A list of tensors corresponding to those requested by `RunGraphRequest.recv_key`.

• optional StepStats step_stats = 2

  If the request asked for execution stats, the cost graph, or the partition graphs, these are returned here. TODO(suharshs): Package these in a RunMetadata instead.

• optional CostGraphDef cost_graph = 3

• repeated GraphDef partition_graph = 4

• error.Code status_code = 5

  If store_errors_in_response_body is true in the request, then optionally the server may return an OK status for the RPC and fill the true status into the fields below, to allow for messages that are too long to fit in metadata.

• string status_error_message = 6

Metadata output (i.e., non-Tensor) for a single Run() call.

Used in: ProfileResponse, RunCallableResponse, RunStepResponse

• optional StepStats step_stats = 1

  Statistics traced for this step. Populated if tracing is turned on via the "RunOptions" proto. EXPERIMENTAL: The format and set of events may change in future versions.

• optional CostGraphDef cost_graph = 2

  The cost graph for the computation defined by the run call.

• repeated GraphDef partition_graphs = 3

  Graphs of the partitions executed by executors.

Options for a single Run() call.

Used in: CallableOptions, RunStepRequest

• RunOptions.TraceLevel trace_level = 1

• int64 timeout_in_ms = 2

  Time to wait for operation to complete in milliseconds.

• int32 inter_op_thread_pool = 3

  The thread pool to use, if session_inter_op_thread_pool is configured.

• bool output_partition_graphs = 5

  Whether the partition graph(s) executed by the executor(s) should be outputted via RunMetadata.

• optional DebugOptions debug_options = 6

  EXPERIMENTAL. Options used to initialize DebuggerState, if enabled.

• bool report_tensor_allocations_upon_oom = 7

  When enabled, causes tensor allocation information to be included in the error message when the Run() call fails because the allocator ran out of memory (OOM). Enabling this option can slow down the Run() call.

TODO(pbar) Turn this into a TraceOptions proto which allows tracing to be controlled in a more orthogonal manner?

Used in: RunOptions

• NO_TRACE = 0

• SOFTWARE_TRACE = 1

• HARDWARE_TRACE = 2

• FULL_TRACE = 3

Used as request type in: grpc.MasterService.RunStep

• string session_handle = 1

  REQUIRED: session_handle must be returned by a CreateSession call to the same master service.

• repeated NamedTensorProto feed = 2

  Tensors to be fed in the step. Each feed is a named tensor.

• repeated string fetch = 3

  Fetches. A list of tensor names. The caller expects a tensor to be returned for each fetch[i] (see RunStepResponse.tensor). The order of specified fetches does not change the execution order.

• repeated string target = 4

  Target Nodes. A list of node names. The named nodes will be run to but their outputs will not be fetched.

• optional RunOptions options = 5

  Options for the run call.

• string partial_run_handle = 6

  Partial run handle (optional). If specified, this will be a partial run execution, run up to the specified fetches.

• bool store_errors_in_response_body = 7

  If true then some errors, e.g., execution errors that have long error messages, may return an OK RunStepResponse with the actual error saved in the status_code/status_error_message fields of the response body. This is a workaround since the RPC subsystem may truncate long metadata messages.

Used as response type in: grpc.MasterService.RunStep

• repeated NamedTensorProto tensor = 1

  NOTE: The order of the returned tensors may or may not match the fetch order specified in RunStepRequest.

• optional RunMetadata metadata = 2

  Returned metadata if requested in the options.

• error.Code status_code = 3

  If store_errors_in_response_body is true in the request, then optionally the server may return an OK status for the RPC and fill the true status into the fields below, to allow for messages that are too long to fit in metadata.

• string status_error_message = 4

Used in: VariableDef

• string full_name = 1

  Name of the full variable of which this is a slice.

• repeated int64 full_shape = 2

  Shape of the full variable.

• repeated int64 var_offset = 3

  Offset of this variable into the full variable.

• repeated int64 var_shape = 4

  Shape of this variable.

SavedModel is the high level serialization format for TensorFlow Models. See [todo: doc links, similar to session_bundle] for more information.

• int64 saved_model_schema_version = 1

  The schema version of the SavedModel instance. Used for versioning when making future changes to the specification/implementation. Initial value at release will be 1.

• repeated MetaGraphDef meta_graphs = 2

  One or more MetaGraphs.

Saved tensor slice: it stores the name of the tensors, the slice, and the raw data.

Used in: SavedTensorSlices

• string name = 1

  Name of the tensor that this slice belongs to. This must be identical to the name used to encode the key for this record.

• optional TensorSliceProto slice = 2

  Extent of the slice. Must have one entry for each of the dimension of the tensor that this slice belongs to.

• optional TensorProto data = 3

  The raw data of the slice is stored as a TensorProto. Only raw data are stored (we don't fill in fields such as dtype or tensor_shape).

Metadata describing the set of slices of the same tensor saved in a checkpoint file.

Used in: SavedTensorSliceMeta

• string name = 1

  Name of the tensor.

• optional TensorShapeProto shape = 2

  Shape of the tensor

• DataType type = 3

  Type of the tensor

• repeated TensorSliceProto slice = 4

  Explicit list of slices saved in the checkpoint file.

Metadata describing the set of tensor slices saved in a checkpoint file. It is always stored at the beginning of each checkpoint file.

Used in: SavedTensorSlices

• repeated SavedSliceMeta tensor = 1

  Each SavedSliceMeta describes the slices for one tensor.

• optional VersionDef versions = 2

  Compatibility version of this checkpoint. See core/public/version.h for version history.

Each record in a v3 checkpoint file is a serialized SavedTensorSlices message.

• optional SavedTensorSliceMeta meta = 1

  This is only present at the first item of each checkpoint file and serves as a table of contents, listing all the tensor slices saved in this file.

• optional SavedSlice data = 2

  This exists in all but the first item of each checkpoint file.

Protocol buffer representing the configuration of a Saver.

Used in: MetaGraphDef

• string filename_tensor_name = 1

  The name of the tensor in which to specify the filename when saving or restoring a model checkpoint.

• string save_tensor_name = 2

  The operation to run when saving a model checkpoint.

• string restore_op_name = 3

  The operation to run when restoring a model checkpoint.

• int32 max_to_keep = 4

  Maximum number of checkpoints to keep. If 0, no checkpoints are deleted.

• bool sharded = 5

  Shard the save files, one per device that has Variable nodes.

• float keep_checkpoint_every_n_hours = 6

  How often to keep an additional checkpoint. If not specified, only the last "max_to_keep" checkpoints are kept; if specified, in addition to keeping the last "max_to_keep" checkpoints, an additional checkpoint will be kept for every n hours of training.

• SaverDef.CheckpointFormatVersion version = 7

A version number that identifies a different on-disk checkpoint format. Usually, each subclass of BaseSaverBuilder works with a particular version/format. However, it is possible that the same builder may be upgraded to support a newer checkpoint format in the future.

Used in: SaverDef

• LEGACY = 0

  Internal legacy format.

• V1 = 1

  Deprecated format: tf.Saver() which works with tensorflow::table::Table.

• V2 = 2

  Current format: more efficient.

• optional Features context = 1

• optional FeatureLists feature_lists = 2

Defines the configuration of a single TensorFlow server.

Used in: CreateWorkerSessionRequest

• optional ClusterDef cluster = 1

  The cluster of which this server is a member.

• string job_name = 2

  The name of the job of which this server is a member. NOTE(mrry): The `cluster` field must contain a `JobDef` with a `name` field that matches this name.

• int32 task_index = 3

  The task index of this server in its job. NOTE: The `cluster` field must contain a `JobDef` with a matching `name` and a mapping in its `tasks` field for this index.

• optional ConfigProto default_session_config = 4

  The default configuration for sessions that run on this server.

• string protocol = 5

  The protocol to be used by this server. Acceptable values include: "grpc".

Description of the session when an op is run.

Used in: OpInfo, OpPerformance

• int64 intra_op_parallelism = 1

Protocol buffer used for logging session state.

Used in: Event

• SessionLog.SessionStatus status = 1

• string checkpoint_path = 2

  This checkpoint_path contains both the path and filename.

• string msg = 3

Used in: SessionLog

• STATUS_UNSPECIFIED = 0

• START = 1

• STOP = 2

• CHECKPOINT = 3

For communicating live events back to a coordinator

• repeated Event event = 1

SignatureDef defines the signature of a computation supported by a TensorFlow graph. For example, a model with two loss computations, sharing a single input, might have the following signature_def map. Note that across the two SignatureDefs "loss_A" and "loss_B", the input key, output key, and method_name are identical, and will be used by system(s) that implement or rely upon this particular loss method. The output tensor names differ, demonstrating how different outputs can exist for the same method. signature_def { key: "loss_A" value { inputs { key: "input" value { name: "input:0" dtype: DT_STRING tensor_shape: ... } } outputs { key: "loss_output" value { name: "loss_output_A:0" dtype: DT_FLOAT tensor_shape: ... } } } ... method_name: "some/package/compute_loss" } signature_def { key: "loss_B" value { inputs { key: "input" value { name: "input:0" dtype: DT_STRING tensor_shape: ... } } outputs { key: "loss_output" value { name: "loss_output_B:0" dtype: DT_FLOAT tensor_shape: ... } } } ... method_name: "some/package/compute_loss" }

Used in: MetaGraphDef

• map<string, TensorInfo> inputs = 1

  Named input parameters.

• map<string, TensorInfo> outputs = 2

  Named output parameters.

• string method_name = 3

  Extensible method_name information enabling third-party users to mark a SignatureDef as supporting a particular method. This enables producers and consumers of SignatureDefs, e.g. a model definition library and a serving library to have a clear hand-off regarding the semantics of a computation. Note that multiple SignatureDefs in a single MetaGraphDef may have the same method_name. This is commonly used to support multi-headed computation, where a single graph computation may return multiple results.

Used in: EmbeddingInfo

• string image_path = 1

• repeated uint32 single_image_dim = 2

  [width, height] of a single image in the sprite.

Used in: LabeledStepStats, RunGraphResponse, RunMetadata

• repeated DeviceStepStats dev_stats = 1

A Summary is a set of named values to be displayed by the visualizer. Summaries are produced regularly during training, as controlled by the "summary_interval_secs" attribute of the training operation. Summaries are also produced at the end of an evaluation.

Used in: Event

• repeated Summary.Value value = 1

  Set of values for the summary.

Used in: Value

• float sample_rate = 1

  Sample rate of the audio in Hz.

• int64 num_channels = 2

  Number of channels of audio.

• int64 length_frames = 3

  Length of the audio in frames (samples per channel).

• bytes encoded_audio_string = 4

  Encoded audio data and its associated RFC 2045 content type (e.g. "audio/wav").

• string content_type = 5

Used in: Value

• int32 height = 1

  Dimensions of the image.

• int32 width = 2

• int32 colorspace = 3

  Valid colorspace values are 1 - grayscale 2 - grayscale + alpha 3 - RGB 4 - RGBA 5 - DIGITAL_YUV 6 - BGRA

• bytes encoded_image_string = 4

  Image data in encoded format. All image formats supported by image_codec::CoderUtil can be stored here.

Used in: Summary

• string node_name = 7

  This field is deprecated and will not be set.

• string tag = 1

  Tag name for the data. Used by TensorBoard plugins to organize data. Tags are often organized by scope (which contains slashes to convey hierarchy). For example: foo/bar/0

• optional SummaryMetadata metadata = 9

  Contains metadata on the summary value such as which plugins may use it. Take note that many summary values may lack a metadata field. This is because the FileWriter only keeps a metadata object on the first summary value with a certain tag for each tag. TensorBoard then remembers which tags are associated with which plugins. This saves space.

• oneof value

  Value associated with the tag.

  • float simple_value = 2

  • bytes obsolete_old_style_histogram = 3

  • Image image = 4

  • HistogramProto histo = 5

  • Audio audio = 6

  • TensorProto tensor = 8

Metadata associated with a series of Summary data

• string type_hint = 1

  Hint on how plugins should process the data in this series. Supported values include "scalar", "histogram", "image", "audio"

A SummaryMetadata encapsulates information on which plugins are able to make use of a certain summary value.

Used in: Summary.Value

• optional SummaryMetadata.PluginData plugin_data = 1

  Data that associates a summary with a certain plugin.

• string display_name = 2

  Display name for viewing in TensorBoard.

• string summary_description = 3

  Longform readable description of the summary sequence. Markdown supported.

Used in: SummaryMetadata

• string plugin_name = 1

  The name of the plugin this data pertains to.

• bytes content = 2

  The content to store for the plugin. The best practice is for this to be a binary serialized protocol buffer.

For logging the metadata output for a single session.run() call.

Used in: Event

• string tag = 1

  Tag name associated with this metadata.

• bytes run_metadata = 2

  Byte-encoded version of the `RunMetadata` proto in order to allow lazy deserialization.

Defines a connection between two tensors in a `GraphDef`.

Used in: CallableOptions

• string from_tensor = 1

  A tensor name. The value of this tensor will be substituted for the tensor named in `to_tensor`.

• string to_tensor = 2

  A tensor name. The value of this tensor will be bound to the value of the tensor named in `from_tensor`.

Used in: MemoryLogTensorAllocation, MemoryLogTensorOutput, NodeOutput

• DataType dtype = 1

  Data type of tensor elements

• optional TensorShapeProto shape = 2

  Shape of the tensor.

• optional AllocationDescription allocation_description = 4

  Information about the size and allocator used for the data

Information about a Tensor necessary for feeding or retrieval.

Used in: AssetFileDef, SignatureDef

• oneof encoding

  • string name = 1

    For dense `Tensor`s, the name of the tensor in the graph.

  • TensorInfo.CooSparse coo_sparse = 4

    There are many possible encodings of sparse matrices (https://en.wikipedia.org/wiki/Sparse_matrix). Currently, TensorFlow uses only the COO encoding. This is supported and documented in the SparseTensor Python class.

• DataType dtype = 2

• optional TensorShapeProto tensor_shape = 3

  The static shape should be recorded here, to the extent that it can be known in advance. In the case of a SparseTensor, this field describes the logical shape of the represented tensor (aka dense_shape).

For sparse tensors, The COO encoding stores a triple of values, indices, and shape.

Used in: TensorInfo

• string values_tensor_name = 1

  The shape of the values Tensor is [?]. Its dtype must be the dtype of the SparseTensor as a whole, given in the enclosing TensorInfo.

• string indices_tensor_name = 2

  The indices Tensor must have dtype int64 and shape [?, ?].

• string dense_shape_tensor_name = 3

  The dynamic logical shape represented by the SparseTensor is recorded in the Tensor referenced here. It must have dtype int64 and shape [?].

Protocol buffer representing a tensor.

Used in: AttrValue, AttrValue.ListValue, EventReply, FixedLenFeatureProto, NamedTensorProto, OpInfo.TensorProperties, RecvTensorResponse, RunCallableRequest, RunCallableResponse, SavedSlice, Summary.Value, VariantTensorDataProto

• DataType dtype = 1

• optional TensorShapeProto tensor_shape = 2

  Shape of the tensor. TODO(touts): sort out the 0-rank issues.

• int32 version_number = 3

  Version number. In version 0, if the "repeated xxx" representations contain only one element, that element is repeated to fill the shape. This makes it easy to represent a constant Tensor with a single value.

• bytes tensor_content = 4

  Serialized raw tensor content from either Tensor::AsProtoTensorContent or memcpy in tensorflow::grpc::EncodeTensorToByteBuffer. This representation can be used for all tensor types. The purpose of this representation is to reduce serialization overhead during RPC call by avoiding serialization of many repeated small items.

• repeated int32 half_val = 13

  DT_HALF, DT_BFLOAT16. Note that since protobuf has no int16 type, we'll have some pointless zero padding for each value here.

• repeated float float_val = 5

  DT_FLOAT.

• repeated double double_val = 6

  DT_DOUBLE.

• repeated int32 int_val = 7

  DT_INT32, DT_INT16, DT_INT8, DT_UINT8.

• repeated bytes string_val = 8

  DT_STRING

• repeated float scomplex_val = 9

  DT_COMPLEX64. scomplex_val(2*i) and scomplex_val(2*i+1) are real and imaginary parts of i-th single precision complex.

• repeated int64 int64_val = 10

  DT_INT64

• repeated bool bool_val = 11

  DT_BOOL

• repeated double dcomplex_val = 12

  DT_COMPLEX128. dcomplex_val(2*i) and dcomplex_val(2*i+1) are real and imaginary parts of i-th double precision complex.

• repeated ResourceHandleProto resource_handle_val = 14

  DT_RESOURCE

• repeated VariantTensorDataProto variant_val = 15

  DT_VARIANT

• repeated uint32 uint32_val = 16

  DT_UINT32

• repeated uint64 uint64_val = 17

  DT_UINT64

Dimensions of a tensor.

Used in: AttrValue, AttrValue.ListValue, BundleEntryProto, CostGraphDef.Node.OutputInfo, CppShapeInferenceResult, CppShapeInferenceResult.HandleShapeAndType, FixedLenFeatureProto, OpInfo.TensorProperties, RemoteFusedGraphExecuteInfo.TensorShapeTypeProto, SavedSliceMeta, TensorDescription, TensorInfo, TensorProto, contrib.mpi_collectives.MPIRequest, tf2xla.Feed, tf2xla.TensorMetadata, tfprof.GraphNodeProto

• repeated TensorShapeProto.Dim dim = 2

  Dimensions of the tensor, such as {"input", 30}, {"output", 40} for a 30 x 40 2D tensor. If an entry has size -1, this corresponds to a dimension of unknown size. The names are optional. The order of entries in "dim" matters: It indicates the layout of the values in the tensor in-memory representation. The first entry in "dim" is the outermost dimension used to layout the values, the last entry is the innermost dimension. This matches the in-memory layout of RowMajor Eigen tensors. If "dim.size()" > 0, "unknown_rank" must be false.

• bool unknown_rank = 3

  If true, the number of dimensions in the shape is unknown. If true, "dim.size()" must be 0.

One dimension of the tensor.

Used in: TensorShapeProto

• int64 size = 1

  Size of the tensor in that dimension. This value must be >= -1, but values of -1 are reserved for "unknown" shapes (values of -1 mean "unknown" dimension). Certain wrappers that work with TensorShapeProto may fail at runtime when deserializing a TensorShapeProto containing a dim value of -1.

• string name = 2

  Optional name of the tensor dimension.

Can only be interpreted if you know the corresponding TensorShape.

Used in: BundleEntryProto, SavedSlice, SavedSliceMeta

• repeated TensorSliceProto.Extent extent = 1

  Extent of the slice in all tensor dimensions. Must have one entry for each of the dimension of the tensor that this slice belongs to. The order of sizes is the same as the order of dimensions in the TensorShape.

Extent of the slice in one dimension.

Either both or no attributes must be set. When no attribute is set means: All data in that dimension.

Used in: TensorSliceProto

• int64 start = 1

  Start index of the slice, starting at 0.

• oneof has_length

  Length of the slice: if the length is missing or -1 we will interpret this as "everything in this dimension". We use "oneof" to preserve information about whether the length is present without changing the serialization format from the prior proto2 version of this proto.

  • int64 length = 2

The output of one benchmark / test run. Each run contains a list of tests or benchmarks, stored as BenchmarkEntry messages. This message should be emitted by the reporter (which runs the test / BM in a subprocess and then reads the emitted BenchmarkEntry messages; usually from a serialized json file, finally collecting them along with additional information about the test run.

• string target = 1

  The target of the run, e.g.: //tensorflow/core:kernels_adjust_contrast_op_benchmark_test

• optional BenchmarkEntries entries = 2

  The list of tests or benchmarks in this run.

• optional BuildConfiguration build_configuration = 3

  The configuration of the build (compiled opt? with cuda? any copts?)

• optional CommitId commit_id = 4

  The commit id (git hash or changelist)

• int64 start_time = 5

  The time the run started (in seconds of UTC time since Unix epoch)

• double run_time = 6

  The amount of time the total run took (wall time in seconds)

• optional MachineConfiguration machine_configuration = 7

  Machine-specific parameters (Platform and CPU info)

• optional RunConfiguration run_configuration = 8

  Run-specific parameters (arguments, etc)

• string name = 9

  Benchmark target identifier.

• TestResults.BenchmarkType benchmark_type = 10

• string run_mode = 11

  Used for differentiating between continuous and debug builds. Must be one of: * cbuild: results from continuous build. * presubmit: results from oneshot requests. * culprit: results from culprit finder rerun.

The type of benchmark.

Used in: TestResults

• UNKNOWN = 0

  Fallback for protos written before Type was introduced.

• CPP_MICROBENCHMARK = 1

• PYTHON_BENCHMARK = 2

• ANDROID_BENCHMARK = 3

Used in: ConfigProto

• int32 num_threads = 1

  The number of threads in the pool. 0 means the system picks a value based on where this option proto is used (see the declaration of the specific field for more info).

• string global_name = 2

  The global name of the threadpool. If empty, then the threadpool is made and used according to the scope it's in - e.g., for a session threadpool, it is used by that session only. If non-empty, then: - a global threadpool associated with this name is looked up or created. This allows, for example, sharing one threadpool across many sessions (e.g., like the default behavior, if inter_op_parallelism_threads is not configured), but still partitioning into a large and small pool. - if the threadpool for this global_name already exists, then it is an error if the existing pool was created using a different num_threads value as is specified on this call. - threadpools created this way are never garbage collected.

Used in: ProfileRequest

• string output_formats = 2

  Required formats for the tool, it should be one of "json", "proto", "raw" etc. If not specified (backward compatible), use default format, i.e. most tools use json format.

• bool save_to_repo = 3

  Whether save the result directly to repository or pass it back to caller. Default to false for backward compatibilities.

Used in: TracingRequest

• double duration = 1

  Length of the trace to be taken, in seconds.

• bool use_step_profiler = 2

  If true, capture step profile locally in each worker. Currently unimplemented.

• bool use_kernel_profiler = 3

  If true, capture kernel events from each worker.

• bool use_extended_profiler = 4

  If true, capture extended profiling events from TensorFlow process.

• bool use_gpu_profiler = 5

  If true, capture GPU profiling events locally on each machine. Currently unimplemented.

• bool use_sample_profiler = 6

  If true, collect sampled profile events. Currently unimplemented.

Out-of-band request to configure distributed tracing.

Used as request type in: grpc.WorkerService.Tracing

• optional TraceOpts options = 1

Used as response type in: grpc.WorkerService.Tracing

(message has no fields)

Protocol buffer representing the values in ControlFlowContext.

Used in: CondContextDef, WhileContextDef

• repeated string values = 1

  Value names that have been seen in this context.

• map<string, string> external_values = 2

  Value names referenced by but external to this context.

Used in: FeatureConfiguration

• DataType dtype = 1

• string values_output_tensor_name = 2

• string indices_output_tensor_name = 3

• string shapes_output_tensor_name = 4

Protocol buffer representing a Variable.

• string variable_name = 1

  Name of the variable tensor.

• string initial_value_name = 6

  Name of the tensor holding the variable's initial value.

• string initializer_name = 2

  Name of the initializer op.

• string snapshot_name = 3

  Name of the snapshot tensor.

• optional SaveSliceInfoDef save_slice_info_def = 4

  Support for saving variables as slices of a larger variable.

• bool is_resource = 5

  Whether to represent this as a ResourceVariable.

Protocol buffer representing the serialization format of DT_VARIANT tensors.

Used in: TensorProto

• string type_name = 1

  Name of the type of objects being serialized.

• bytes metadata = 2

  Portions of the object that are not Tensors.

• repeated TensorProto tensors = 3

  Tensors contained within objects being serialized.

Version information for a piece of serialized data There are different types of versions for each type of data (GraphDef, etc.), but they all have the same common shape described here. Each consumer has "consumer" and "min_producer" versions (specified elsewhere). A consumer is allowed to consume this data if producer >= min_producer consumer >= min_consumer consumer not in bad_consumers

Used in: BundleHeaderProto, GraphDef, SavedTensorSliceMeta

• int32 producer = 1

  The version of the code that produced this data.

• int32 min_consumer = 2

  Any consumer below this version is not allowed to consume this data.

• repeated int32 bad_consumers = 3

  Specific consumer versions which are disallowed (e.g. due to bugs).

Protocol buffer representing a WhileContext object.

Used in: ControlFlowContextDef

• string context_name = 1

  Name of the context.

• int32 parallel_iterations = 2

  The number of iterations allowed to run in parallel.

• bool back_prop = 3

  Whether backprop is enabled for this while loop.

• bool swap_memory = 4

  Whether GPU-CPU memory swap is enabled for this loop.

• string pivot_name = 5

  Name of the pivot tensor.

• string pivot_for_pred_name = 6

  Name of the pivot_for_pred tensor.

• string pivot_for_body_name = 7

  Name of the pivot_for_body tensor.

• repeated string loop_exit_names = 8

  List of names for exit tensors.

• repeated string loop_enter_names = 10

  List of names for enter tensors.

• optional ValuesDef values_def = 9

  Values and external values in control flow context.

• string maximum_iterations_name = 11

  Optional name of the maximum_iterations tensor.

• repeated ControlFlowContextDef nested_contexts = 12

  Contexts contained inside this context (e.g. nested whiles).