package tensorflow
Get desktop application:
View/edit binary Protocol Buffers messages
Coordination Service defines a TensorFlow service that controls and coordinates distributed execution in a cluster of multiple tasks. The service keeps track of the cluster configuration and the state of cluster members or the leader depending on the role of the current task. The distributed runtime leverages this service to coordinate and perform cluster initialization, check the healthiness of tasks, and propagate error messages to the cluster.
Blocks until all (or a subset of) tasks are at the barrier or the barrier fails. `barrier_id` should be unique across barriers. Once the barrier has passed or failed, subsequent calls will not block, and immediately respond with the previous response. The first WaitAtBarrier() call received by the service for a particular barrier id is special in that it determines the barrier deadline based on timeout duration. However, if subsequent calls by different agents specify a different set of `tasks` for the same `barrier_id`, the barrier will fail instantly. If no tasks are specified (default), the barrier will block for all the connected tasks. Possible service errors: - DeadlineExceeded: Timed out waiting for specified tasks at the barrier. Deadline is determined by the server timestamp when it receives the first WaitAtBarrier() + timeout duration. - Cancelled: One of the tasks called CancelBarrier(). - Aborted: Service is shutting down. - Internal: Any participating task is in ERROR state. - InvalidArgument: (1) Conflicting tasks specified by different agents for the same barrier, (2) one of the participating tasks is not in the cluster, or (3) task making the request is not included in the list of participating tasks.
message
coordination_service.proto:212Request and response messages for generic sync barriers.
string barrier_id = 1
int64 barrier_timeout_in_ms = 2
repeated tasks = 3
Denotes list of tasks that will wait for the barrier. If unspecified, it implies that the entire cluster is participating in the barrier.
optional source_task = 4
Task that is making the request.
message
coordination_service.proto:222(message has no fields)
Aborts the barrier if it is ongoing. Current and future WaitAtBarrier() calls with the same id will return a CANCELLED error status. Possible service errors: - FailedPrecondition: Barrier has already been passed.
message
coordination_service.proto:225Request and response messages for cancelling generic sync barriers.
string barrier_id = 1
optional source_task = 2
Task that is making the request.
message
coordination_service.proto:231(message has no fields)
Delete configuration key-value. If is_directory is set in request, recursively clean up all key-values under the path specified by `key`.
message
coordination_service.proto:204Request and response messages for deleting configuration key-value data. When is_directory is true, delete key-values recursively under `key`.
string key = 1
bool is_directory = 2
message
coordination_service.proto:209(message has no fields)
Get configuration key-value. The request blocks until the key-value data becomes available (i.e., set by a task in the cluster).
message
coordination_service.proto:177Request and response messages for getting configuration key-value data.
string key = 1
message
coordination_service.proto:181optional kv = 1
Same as GetKeyValue, but returns all values that have keys which are prefixed with the directory key.
message
coordination_service.proto:193string directory_key = 1
message
coordination_service.proto:197string directory_key = 1
repeated kv = 2
Get the state of a remote task. Specifically, RPC returns a CoordinatedTaskState, and if the task is in an error status, returns a non-OK error code, non-empty error message and error payload.
message
coordination_service.proto:153Request and response messages for getting state of a remote task.
repeated source_task = 1
message
coordination_service.proto:157repeated task_state = 1
Heartbeat message from task to coordination service. Heartbeat is sent from a task to refresh its timestamp on leader to avoid it becoming stale. RPC responds immediately after refreshing the timestamp on leader.
message
coordination_service.proto:84Request and response messages for sending heartbeats.
fixed64 incarnation = 3
optional source_task = 4
message
coordination_service.proto:91fixed64 leader_incarnation = 1
If there are failures in cluster, use additional metadata in response to broadcast error code and message to other tasks.
Insert configuration key-value that will be accessible to all cluster tasks. The key can be formatted as Unix file path with hierarchy. The coordination service key-value store should only be used for cluster configuration data.
message
coordination_service.proto:170Request and response messages for inserting configuration key-value data.
optional kv = 1
message
coordination_service.proto:174(message has no fields)
Register task to coordination service so that the service starts to track liveness of the task. RPC blocks and returns only when it registers to the service successfully, or error happens in the registering process.
message
coordination_service.proto:69Request and response messages for registering a task to the cluster leader. A task is uniquely represented by its `job_name`, `task_id` and `incarnation`. Leader responds with its `incarnation` to identify a leader process.
fixed64 incarnation = 3
optional source_task = 5
message
coordination_service.proto:79fixed64 leader_incarnation = 1
Report task error to coordination service. RPC sets the service-side task state to error, and propagate the error to other tasks in the cluster.
message
coordination_service.proto:142Request and response messages for reporting errors to service instance.
int32 error_code = 1
string error_message = 2
optional error_origin = 5
message
coordination_service.proto:150(message has no fields)
Report error to the task. RPC sets the receiving instance of coordination service agent to error state permanently. TODO(b/195990880): Consider splitting this into a different RPC service.
message
coordination_service.proto:131Request and response messages for reporting errors to task.
int32 error_code = 1
string error_message = 2
optional error_payload = 5
message
coordination_service.proto:139(message has no fields)
Disconnects task from the service if it is in an ERROR state, thereby allowing it to reconnect via RegisterTask() in the future.
message
coordination_service.proto:124Request and response messages for resetting a task state in the service.
optional source_task = 1
message
coordination_service.proto:128(message has no fields)
Disconnects task from the service. If `shutdown_barrier_timeout_in_ms` is specified in the config, blocks until all tasks reach the barrier before disconnecting together. If the barrier times out, tasks at the barrier will still disconnect, while an error is reported to tasks that did not reach the barrier on time.
message
coordination_service.proto:117Request and response messages for disconnecting a task from the service.
optional source_task = 1
message
coordination_service.proto:121(message has no fields)
Get configuration key-value. The request does not block, but returns an error if the requested key does not exist.
message
coordination_service.proto:185string key = 1
message
coordination_service.proto:189optional kv = 1
Wait for all tasks in the cluster to be up and running. The RPC request only gets responded when all tasks have registered, or some error occurs.
message
coordination_service.proto:98Request and response messages for waiting for all tasks.
optional local_device_info = 4
All local device attributes on the request sender.
optional source_task = 5
message
coordination_service.proto:108fixed64 leader_incarnation = 1
optional cluster_device_info = 3
All devices in the cluster.
EventListener: Receives Event protos, e.g., from debugged TensorFlow runtime(s).
rpc SendEvents (stream , stream )
debug_service.proto:93Client(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.
Send a collection of source code files being debugged.
message
debug.proto:91repeated source_files = 1
A collection of source code files.
rpc SendTracebacks (, )
debug_service.proto:96Send the tracebacks of a TensorFlow execution call.
message
debug_service.proto:53Data 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 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 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).
////////////////////////////////////////////////////////////////////////////// ProfileAnalysis service provide entry point for profiling TPU and for serving profiled data to Tensorboard through GRPC //////////////////////////////////////////////////////////////////////////////
Enumerate existing sessions and return available profile tools.
message
profiler_analysis.proto:24string repository_root = 1
message
profiler_analysis.proto:34string error_message = 1
Auxiliary error_message.
repeated sessions = 2
If success, the returned sessions information are stored here.
Retrieve specific tool's data for specific session.
message
profiler_analysis.proto:41string repository_root = 1
The place where we will read profile data. We will normally use MODEL_DIR/plugins/profile as the repository root.
string session_id = 2
string host_name = 5
Which host the data is associated. if empty, data from all hosts are aggregated.
string tool_name = 3
Which tool
map<string, string> parameters = 4
Tool's specific parameters. e.g. TraceViewer's viewport etc
message
profiler_analysis.proto:55string 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.
rpc NewSession (, )
profiler_analysis.proto:73Starts 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
profiler_analysis.proto:7optional request = 1
string repository_root = 2
The place where we will dump profile data. We will normally use MODEL_DIR/plugins/profile as the repository root.
repeated string hosts = 3
host or host:port, port will be ignored.
string session_id = 4
message
profiler_analysis.proto:16string error_message = 1
Auxiliary error_message.
bool empty_trace = 2
Whether all hosts had returned a empty trace.
The ProfilerService service retrieves performance information about the programs running on connected devices over a period of time.
rpc Monitor (, )
profiler_service.proto:18Collects profiling data and returns user-friendly metrics.
message
profiler_service.proto:96Next-ID: 4
uint64 duration_ms = 1
Duration for which to profile between each update.
int32 monitoring_level = 2
Indicates the level at which we want to monitor. Currently, two levels are supported: Level 1: An ultra lightweight mode that captures only some utilization metrics. Level 2: More verbose than level 1. Collects utilization metrics, device information, step time information, etc. Do not use this option if the TPU host is being very heavily used.
bool timestamp = 3
True to display timestamp in monitoring result.
message
profiler_service.proto:113Next-ID: 11
string data = 1
Properly formatted string data that can be directly returned back to user.
optional monitor_result = 10
A collection of monitoring results for each field show in data.
rpc Profile (, )
profiler_service.proto:12Starts a profiling session, blocks until it completes, and returns data.
message
profiler_service.proto:77Next-ID: 8
repeated tool_data = 6
Data payload for each required tools.
bool empty_trace = 7
When we write profiling data directly to repository directory, we need a way to figure out whether the captured trace is empty.
rpc Terminate (, )
profiler_service.proto:16Signal to terminate the Profile rpc for a on-going profiling session, The Profile rpc will return successfully and prematurely without timeout. This is used by programmatic mode to end the session in workers.
message
profiler_service.proto:88string session_id = 1
Which session id to terminate.
message
profiler_service.proto:93(message has no fields)
message
allocation_description.proto:11Used in: ,
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.
message
step_stats.proto:15An allocation/de-allocation operation performed by the allocator.
Used in: ,
int64 alloc_micros = 1
The timestamp of the operation.
int64 alloc_bytes = 2
Number of bytes allocated, or de-allocated if negative.
message
step_stats.proto:22Used in:
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 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.
message
api_def.proto:32Used 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 interpreting 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:
string graph_op_name = 1
Name of the op (in the OpDef) to specify the API for.
string deprecation_message = 12
If this op is deprecated, set deprecation message to the message that should be logged when this op is used. The message should indicate alternative op to use, if any.
int32 deprecation_version = 13
Major version when the op will be deleted. For e.g. set this value to 2 if op API should be removed in TensorFlow 2.0 and deprecated in versions before that.
ApiDef.Visibility visibility = 2
repeated endpoint = 3
repeated in_arg = 4
repeated 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 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
message
api_def.proto:81Used in:
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.
message
api_def.proto:104Description 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:
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 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.
message
api_def.proto:63If 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:
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.
bool deprecated = 3
Set if this endpoint is deprecated. If set to true, a message suggesting to use a non-deprecated endpoint instead will be printed. If all endpoints are deprecated, set deprecation_message in ApiDef instead.
int32 deprecation_version = 4
Major version when an endpoint will be deleted. For e.g. set this value to 2 if endpoint should be removed in TensorFlow 2.0 and deprecated in versions before that.
Used in:
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).
message
api_def.proto:136repeated op = 1
message
meta_graph.proto:332An asset file def for a single file or a set of sharded files with the same name.
Used in:
optional 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".
message
attr_value.proto:18Protocol 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: , , , , , , , , , ,
oneof value
bytes s = 2
"string"
int64 i = 3
"int"
float f = 4
"float"
bool b = 5
"bool"
DataType type = 6
"type"
shape = 7
"shape"
tensor = 8
"tensor"
list = 1
any "list(...)"
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".
message
attr_value.proto:20LINT.IfChange
Used in:
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 shape = 7
"list(shape)"
repeated tensor = 8
"list(tensor)"
repeated func = 9
"list(attr)"
message
rewriter_config.proto:14Used in:
bool enable = 1
int32 num_replicas = 2
message
autotune_map.proto:37TODO(b/189530096): Support autotune maps for more ops.
optional conv_map = 2
optional fused_conv_map = 3
message
autotuning.proto:27Used in:
int64 scratch_bytes = 8
optional run_time = 9
optional failure = 7
oneof key
conv = 5
gemm = 6
cuda_conv_plan = 15
algorithm = 16
message
autotuning.proto:62Legacy and unused in new data; superseded by AlgorithmProto.
Used in: ,
int64 algorithm = 1
bool tensor_ops_enabled = 2
message
autotuning.proto:72Legacy and unused in new data; superseded by AlgorithmProto.
Used in: ,
string exec_plan_id = 1
Used in:
UNKNOWN = 0
REDZONE_MODIFIED = 1
Algorithm wrote memory outside its output buffers.
WRONG_RESULT = 2
Algorithm gave a different result from a reference algorithm.
DISQUALIFIED = 3
Algorithm was rejected for failing to run or for known bugs.
message
autotuning.proto:41Used in:
FailureKind kind = 1
string msg = 2
oneof key
For failure_kind == WRONG_RESULT, this field indicates the reference configuration that we compared against. Note that the reference algorithm isn't always correct. However, empirically it's more correct, as it's "algo 0", less fancy than the compared one.
reference_conv = 11
reference_gemm = 12
reference_cuda_conv_plan = 14
reference_algorithm = 15
int64 buffer_address = 13
message
autotuning.proto:67Used in: ,
int64 algorithm = 1
message
autotuning.proto:91optional instr = 1
repeated results = 2
Records all auto-tuning results per algorithm.
optional cudnn_version = 3
optional compute_capability = 4
string device_pci_bus_id = 5
stream_executor::DeviceDescription::pci_bus_id.
string blas_version = 6
message
test_log.proto:130Matches DeviceAttributes
Used in:
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.
message
test_log.proto:67Used in:
repeated entry = 1
message
test_log.proto:42Each 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:
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, > extras = 6
Generic map from result key to value.
repeated metrics = 7
Metric name, value and expected range. This can include accuracy metrics typically used to determine whether the accuracy test has passed
message
bfc_memory_map.proto:28Used in:
int32 bin = 1
int64 total_bytes_in_use = 2
int64 total_bytes_in_bin = 3
int64 total_chunks_in_use = 4
int64 total_chunks_in_bin = 5
message
struct.proto:117A protobuf to represent tf.BoundedTensorSpec.
Used in:
string name = 1
optional shape = 2
DataType dtype = 3
optional minimum = 4
optional maximum = 5
message
test_log.proto:71Used in:
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
message
tensor_bundle.proto:45Describes the metadata related to a checkpointed tensor.
DataType dtype = 1
The tensor dtype and shape.
optional 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 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".
message
tensor_bundle.proto:25Special 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 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:
LITTLE = 0
BIG = 1
message
feature.proto:68LINT.IfChange Containers to hold repeated fundamental values.
Used in:
repeated bytes value = 1
message
test_log.proto:90Used in:
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:
UNSPECIFIED = 0
GRAPH_EXECUTION = 1
EAGER_EXECUTION = 2
message
config.proto:842Defines 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:
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 run_options = 4
Options that will be applied to each run.
repeated 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.
map<string, string> feed_devices = 6
The Tensor objects fed in the callable and fetched from the callable are expected to be backed by host (CPU) memory by default. The options below allow changing that - feeding tensors backed by device memory, or returning tensors that are backed by device memory. The maps below map the name of a feed/fetch tensor (which appears in 'feed' or 'fetch' fields above), to the fully qualified name of the device owning the memory backing the contents of the tensor. For example, creating a callable with the following options: CallableOptions { feed: "a:0" feed: "b:0" fetch: "x:0" fetch: "y:0" feed_devices: { "a:0": "/job:localhost/replica:0/task:0/device:GPU:0" } fetch_devices: { "y:0": "/job:localhost/replica:0/task:0/device:GPU:0" } } means that the Callable expects: - The first argument ("a:0") is a Tensor backed by GPU memory. - The second argument ("b:0") is a Tensor backed by host memory. and of its return values: - The first output ("x:0") will be backed by host memory. - The second output ("y:0") will be backed by GPU memory. FEEDS: It is the responsibility of the caller to ensure that the memory of the fed tensors will be correctly initialized and synchronized before it is accessed by operations executed during the call to Session::RunCallable(). This is typically ensured by using the TensorFlow memory allocators (Device::GetAllocator()) to create the Tensor to be fed. Alternatively, for CUDA-enabled GPU devices, this typically means that the operation that produced the contents of the tensor has completed, i.e., the CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or cuStreamSynchronize()).
map<string, string> fetch_devices = 7
bool fetch_skip_sync = 8
By default, RunCallable() will synchronize the GPU stream before returning fetched tensors on a GPU device, to ensure that the values in those tensors have been produced. This simplifies interacting with the tensors, but potentially incurs a performance hit. If this options is set to true, the caller is responsible for ensuring that the values in the fetched tensors have been produced before they are used. The caller can do this by invoking `Device::Sync()` on the underlying device(s), or by feeding the tensors back to the same Session using `feed_devices` with the same corresponding device name.
message
saved_object_graph.proto:145Used in:
string name = 1
Name of captured tensor
string concrete_function = 2
Name of concrete function which contains the computed graph tensor.
Input for the CheckpointReader fuzz test.
optional meta = 1
repeated data = 2
message
checkpoint_state.proto:7Protocol buffer representing the checkpoint state.
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.
repeated double all_model_checkpoint_timestamps = 3
Unix timestamps corresponding to all_model_checkpoint_paths, indicating when each checkpoint was created.
double last_preserved_timestamp = 4
Unix timestamp indicating the creation time for the last preserved checkpoint.
message
worker.proto:198Used 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.
message
worker.proto:209Used as response type in: grpc.WorkerService.CleanupAll
(message has no fields)
message
worker.proto:323Used as request type in: grpc.WorkerService.CleanupGraph
int64 step_id = 1
message
worker.proto:327Used as response type in: grpc.WorkerService.CleanupGraph
(message has no fields)
message
master.proto:213Used as request type in: grpc.MasterService.CloseSession
Used as field type in:
string session_handle = 1
REQUIRED: session_handle must be returned by a CreateSession call to the same master service.
message
master.proto:219Used as response type in: grpc.MasterService.CloseSession
Used as field type in:
(message has no fields)
message
cluster.proto:81Defines a TensorFlow cluster as a set of jobs.
Used in: ,
repeated job = 1
The jobs that comprise the cluster.
message
device_filters.proto:71Defines the device filters for jobs in a cluster.
Used in:
repeated jobs = 1
message
debug_event.proto:153Code location information: A stack trace with host-name information. Instead of encoding the detailed stack trace, this proto refers to IDs of stack frames stored as `StackFrameWithId` protos.
Used in: ,
string host_name = 1
Host name on which the source files are located.
repeated string stack_frame_ids = 2
ID to a stack frame, each of which is pointed to by a unique ID. The ordering of the frames is consistent with Python's `traceback.extract_tb()`.
message
meta_graph.proto:157CollectionDef 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:
oneof kind
node_list = 1
bytes_list = 2
int64_list = 3
float_list = 4
any_list = 5
message
meta_graph.proto:200AnyList is used for collecting Any protos.
Used in:
repeated value = 1
message
meta_graph.proto:185BytesList 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:
repeated bytes value = 1
message
meta_graph.proto:195FloatList is used for collecting float values.
Used in:
repeated float value = 1
message
meta_graph.proto:190Int64List is used for collecting int, int64 and long values.
Used in:
repeated int64 value = 1
message
meta_graph.proto:168NodeList 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:
repeated string value = 1
message
test_log.proto:77Used in:
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.
message
worker.proto:546Supplies one or more device names as members of the group identified by group_key. Service will respond when all group_size devices become known. All devices in group must have same type.
Used as request type in: grpc.WorkerService.CompleteGroup
int32 group_key = 1
int32 group_size = 2
string device_type = 3
int32 collective_type = 5
optional device_attributes = 6
message
worker.proto:557Gives the complete membership of the group identified by group_key.
Used as response type in: grpc.WorkerService.CompleteGroup
int32 group_key = 1
int32 group_size = 2
string device_type = 3
int32 num_tasks = 4
number of distinct tasks hosting the devices
bytes communicator_key = 7
repeated device_attributes = 8
message
worker.proto:572Supplies data about one collective op belonging to the instance identified by instance_key. Service will respond when all group_size ops have become known. Most of the data being sent is for correctness checking, to ensure that all ops in the instance share common attributes.
Used as request type in: grpc.WorkerService.CompleteInstance
string name = 1
int32 type = 2
DataType data_type = 3
optional shape = 4
int32 group_key = 5
int32 group_size = 6
int32 instance_key = 7
string device_type = 8
repeated int32 subdiv_offset = 9
string device = 10
bool is_source = 11
message
worker.proto:588Confirms that every op in the instance has consistently declared itself. Also gives the source_rank in case of broadcast.
Used as response type in: grpc.WorkerService.CompleteInstance
int32 instance_key = 1
int32 source_rank = 2
Metadata for CompositeTensorVariant, used when serializing as Variant. We define a new message here (rather than directly using TypeSpecProto for the metadata string) to retain flexibility to change the metadata encoding to support additional features.
optional type_spec_proto = 1
message
autotuning.proto:22Used in: ,
int32 major = 1
int32 minor = 2
message
control_flow.proto:32Protocol buffer representing a CondContext object.
Used in:
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 values_def = 5
Values and external values in control flow context.
repeated nested_contexts = 6
Contexts contained inside this context (e.g. nested conds).
message
config.proto:431Session configuration parameters. The system picks appropriate values for fields that are not set.
Used in: , ,
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. If you create an ordinary session, e.g., from Python or C++, then there is exactly one intra op thread pool per process. The first session created determines the number of threads in this pool. All subsequent sessions reuse/share this one global pool. There are notable exceptions to the default behavior described above: 1. There is an environment variable for overriding this thread pool, named TF_OVERRIDE_GLOBAL_THREADPOOL. 2. When connecting to a server, such as a remote `tf.train.Server` instance, then this option will be ignored altogether.
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. Negative means all operations are performed in caller's thread. 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 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 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 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 rpc_options = 13
Options that apply when this session uses the distributed runtime.
optional 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. However, when clusterspec propagation is enabled, this field is ignored and sessions are always isolated.
bool share_cluster_devices_in_session = 17
When true, WorkerSessions are created with device attributes from the full cluster. This is helpful when a worker wants to partition a graph (for example during a PartitionedCallOp).
optional experimental = 16
message
config.proto:550Everything inside Experimental is subject to change and is not subject to API stability guarantees in https://www.tensorflow.org/guide/version_compat.
Used in:
string collective_group_leader = 1
Task name for group resolution.
string executor_type = 3
Which executor to use, the default executor will be used if it is an empty string or "DEFAULT"
int32 recv_buf_max_chunk = 4
Guidance to formatting of large RecvBuf fields for transfer. Any positive value sets the max chunk size. 0 defaults to 4096. Any negative value indicates no max, i.e. one chunk only.
bool use_numa_affinity = 5
If true, and supported by the platform, the runtime will attempt to use NUMA affinity where applicable. One consequence will be the existence of as many CPU devices as there are available NUMA nodes.
bool collective_deterministic_sequential_execution = 6
If true, make collective op execution order sequential and deterministic for potentially concurrent collective instances.
bool collective_nccl = 7
If true, use NCCL for CollectiveOps. This feature is highly experimental.
bool share_session_state_in_clusterspec_propagation = 8
In the following, session state means the value of a variable, elements in a hash table, or any other resource, accessible by worker sessions held by a TF server. When ClusterSpec propagation is enabled, the value of isolate_session_state is ignored when deciding whether to share session states in a TF server (for backwards compatibility reasons). - If share_session_state_in_clusterspec_propagation is true, the session states are shared. - If share_session_state_in_clusterspec_propagation is false, session states are isolated. When clusterspec propagation is not used, the value of share_session_state_in_clusterspec_propagation is ignored when deciding whether to share session states in a TF server. - If isolate_session_state is true, session states are isolated. - If isolate_session_state is false, session states are shared. TODO(b/129330037): Add a single API that consistently treats isolate_session_state and ClusterSpec propagation.
bool disable_thread_spinning = 9
If using a direct session, disable spinning while waiting for work in the thread pool. This may result in higher latency for completing ops, but in the case where there is a lot of spinning may result in lower CPU usage.
bool share_cluster_devices_in_session = 10
This was promoted to a non-experimental API. Please use ConfigProto.share_cluster_devices_in_session instead.
optional session_metadata = 11
Metadata about the session. If set, this can be used by the runtime and the Ops for debugging, monitoring, etc. NOTE: This is currently used and propagated only by the direct session.
bool optimize_for_static_graph = 12
If true, the session may treat the graph as being static for optimization purposes. If this option is set to true when a session is created, the full GraphDef must be passed in a single call to Session::Create(), and Session::Extend() may not be supported.
bool enable_mlir_bridge = 13
This field will eventually be deprecated and replaced by mlir_bridge_rollout (b/166038521). Whether to enable the MLIR-based TF->XLA bridge. This is a replacement to the existing bridge, and not ready for production usage yet. If this option is set to true when a session is created, MLIR is used to perform the set of graph transformations to put the graph in a form that can be executed with delegation of some computations to an accelerator. This builds on the model of XLA where a subset of the graph is encapsulated and attached to a "compile" operation, whose result is fed to an "execute" operation. The kernel for these operations is responsible to lower the encapsulated graph to a particular device.
Experimental.MlirBridgeRollout mlir_bridge_rollout = 17
This field is underdevelopment, for now use enable_mlir_bridge (b/166038521). Whether to enable the MLIR-based TF->XLA bridge.
bool enable_mlir_graph_optimization = 16
Whether to enable the MLIR-based Graph optimizations. This will become a part of standard Tensorflow graph optimization pipeline, currently this is only used for gradual migration and testing new passes that are replacing existing optimizations in Grappler.
bool disable_output_partition_graphs = 14
If true, the session will not store an additional copy of the graph for each subgraph. If this option is set to true when a session is created, the `RunOptions.output_partition_graphs` options must not be set.
int64 xla_fusion_autotuner_thresh = 15
Minimum number of batches run through the XLA graph before XLA fusion autotuner is enabled. Default value of zero disables the autotuner. The XLA fusion autotuner can improve performance by executing a heuristic search on the compiler parameters.
bool use_tfrt = 18
Whether runtime execution uses TFRT.
bool disable_functional_ops_lowering = 21
Whether functional control flow op lowering should be disabled. This is useful when executing within a portable runtime where control flow op kernels may not be loaded due to selective registration.
bool xla_prefer_single_graph_cluster = 22
Provides a hint to XLA auto clustering to prefer forming a single large cluster that encompases most of the graph.
optional coordination_config = 23
Distributed coordination service configurations.
An enum that describes the state of the MLIR bridge rollout.
Used in:
MLIR_BRIDGE_ROLLOUT_UNSPECIFIED = 0
If this field is left unspecified, the MLIR bridge may be selectively enabled on a per graph basis.
MLIR_BRIDGE_ROLLOUT_ENABLED = 1
Enabling the MLIR bridge enables it for all graphs in this session.
MLIR_BRIDGE_ROLLOUT_DISABLED = 2
Disabling the MLIR bridge disables it for all graphs in this session.
MLIR_BRIDGE_ROLLOUT_SAFE_MODE_ENABLED = 3
Enable the MLIR bridge on a per graph basis based on an analysis of the features used in the graph. If the features used by the graph are supported by the MLIR bridge, the MLIR bridge will be used to run the graph.
MLIR_BRIDGE_ROLLOUT_SAFE_MODE_FALLBACK_ENABLED = 4
Enable the MLIR bridge in a fallback mode on a per graph basis based on an analysis of the features used in the graph. Running the MLIR bridge in the fallback mode means that it is executed and it commits all the changes to the TF graph in case of success. And it does not in case of failures and let the old bridge to process the TF graph.
message
control_flow.proto:24Container for any kind of control flow context. Any other control flow contexts that are added below should also be added here.
Used in: ,
oneof ctxt
cond_ctxt = 1
while_ctxt = 2
message
autotune_map.proto:27Used in:
repeated kv_pairs = 1
message
autotune_map.proto:28Used in:
optional key = 1
optional value = 2
message
conv_parameters.proto:34This is the underlying data structure of class ConvParameters, which are used as the keys in cuDNN autotuning maps for retrieving corresponding cuDNN algorithms. This is used as a serialization format for saving/loading autotuning databases.
Used in:
int64 batch = 1
int64 in_depths = 2
int64 out_depths = 3
repeated int64 in = 4
int32 data_format = 5
data_format corresponds to type TensorFormat in third_party/tensorflow/core/util/tensor_format.h.
repeated int64 filter = 6
repeated int64 dilation = 7
repeated int64 stride = 8
repeated int64 padding = 9
DataType dtype = 10
int32 group_count = 11
string device_identifier = 12
A string uniquely identifying a particular GPU model, e.g. V100 vs RTX 2080.
optional fusion = 13
int32 version = 14
The version number of ConvParameters class. Offline autotune results whose version number is different from the runtime's version number (defined in ConvParameters::kVersion) will be rejected and ignored by LoadSerializedAutotuneMaps. This ensures that we will not load out-of-date autotune results.
message
conv_parameters.proto:37This stores the information for fused convolution operations where an activation and a side input might follow the convolution.
Used in:
bool is_contrib = 1
If true, this proto corresponds to a FusedConvBiasActivation operation implemented in the contrib library, otherwise this proto corresponds to the FusedConv operation implemented in the core library. Compared with FusedConv, FusedConvBiasActivation supports more types of activation function (including no activation) as well as the side_input. For now they have same type of keys in autotune maps, but the semantics of some fields (like padding) are different. So we add this field to distinguish them. TODO(b/177365158) Remove this field once these two operations are merged.
stream_executor.dnn.ActivationMode activation_mode = 2
double conv_scale = 3
double side_input_scale = 4
message
conv_autotuning.proto:13A convolution. Currently it's only used for logging. In the future, we may want to use it in the API as well.
stream_executor.dnn.ConvolutionKind kind = 1
optional input = 2
optional filter = 3
optional output = 4
optional conv_desc = 5
double conv_scale = 6
result = conv_scale * conv(...) + side_value_scale * side_value. side_value is an arbitrary buffer if activation is not none. Otherwise, it has to be the result buffer (using its old values).
double side_value_scale = 7
stream_executor.dnn.ActivationMode activation = 8
int64 input_address = 9
int64 filter_address = 10
int64 output_address = 11
int64 bias_address = 12
int64 side_input_address = 13
message
coordination_config.proto:9Represents a job type and the number of tasks under this job. For example, ("worker", 20) implies that there will be 20 worker tasks.
Used in:
string name = 1
int32 num_tasks = 2
message
coordination_service.proto:11Represents a remote worker task, specified by job name and task id.
Used in: , , , , , , , , , ,
string job_name = 1
int32 task_id = 2
Represents the state of a remote worker
Used in:
TASKSTATE_UNSPECIFIED = 0
TASKSTATE_UNSPECIFIED is an invalid state such that indicates a bug.
TASKSTATE_UNINITIALIZED = 1
TASKSTATE_UNINITIALIZED is an agent-only state. While the agent is disconnected, the service has no way of knowing if the task is initialized/uninitialized.
TASKSTATE_DISCONNECTED = 2
TASKSTATE_CONNECTED = 3
TASKSTATE_ERROR = 4
message
coordination_service.proto:43Used in:
optional task = 1
CoordinatedTaskState state = 2
int32 error_code = 3
string error_message = 4
optional error_payload = 5
message
coordination_config.proto:16Coordination service configuration parameters. The system picks appropriate values for fields that are not set.
Used in:
string service_type = 1
Type of coordination service implementation to enable. For example, setting the service type as "standalone" starts a service instance on the leader task to provide the coordination services such as heartbeats and consistent key-value store.
string service_leader = 2
Address where the coordination service instance is hosted.
bool enable_health_check = 3
Whether to enable the health check mechanism.
int64 cluster_register_timeout_in_ms = 4
Maximum wait time for all members in the cluster to be registered.
int64 heartbeat_timeout_in_ms = 5
Heartbeat timeout, if a task does not record heartbeat in this time window, it will be considered disconnected. Note: This is also used as a grace period to accept any heartbeats after the agent has disconnected, to account for the lag time between the service recording the state change and the agent stopping heartbeats.
repeated coordinated_job_list = 10
int64 shutdown_barrier_timeout_in_ms = 7
Denotes how long to wait for all coordination agents to reach the barriers (after the first shutdown request) before disconnecting together. If set to 0, no barrier is imposed upon shutdown and each worker can disconnect individually.
bool agent_destruction_without_shutdown = 8
If set, agents do not make an explicit Shutdown() call. Service will only find out about the disconnecte agent via stale heartbeats. Used for testing.
repeated string recoverable_jobs = 9
The list of jobs which are recoverable. If a task in this list fails, it will not propagate error to other tasks. If empty, no jobs will be recoverable and every task failure will cause error propagation to other tasks.
message
coordination_service.proto:58Used in: ,
oneof type
tf = 1
xla = 2
message
coordination_service.proto:32Status payload for all coordination service errors. Note: an empty proto may be set if the error is triggered by the task's own agent calls (i.e. not propagated by the service from another remote task).
Used in: ,
bool is_reported_error = 3
If true, error is reported via the agent API by the user (and not an internal service error).
optional source_task = 4
Denotes which task hit the error. If unset, the error originated from the same task that is processing this error.
message
cost_graph.proto:14Used in: ,
repeated node = 1
repeated cost = 2
message
cost_graph.proto:81Total cost of this graph, typically used for balancing decisions.
Used in:
float cost = 1
Aggregated cost value.
string dimension = 2
Aggregated cost dimension (e.g. 'memory', 'compute', 'network').
message
cost_graph.proto:15Used in:
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 input_info = 4
repeated 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.
bool inaccurate = 17
Are the costs inaccurate?
message
cost_graph.proto:29Inputs 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:
int32 preceding_node = 1
int32 preceding_port = 2
message
cost_graph.proto:36Outputs of this node.
Used in:
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 shape = 3
DataType dtype = 4
message
cpp_shape_inference.proto:33repeated int32 input_tensors_needed = 1
repeated int32 input_tensors_as_shapes_needed = 2
message
cpp_shape_inference.proto:12optional shape = 1
optional handle_data = 4
message
cpp_shape_inference.proto:20Used in:
bool is_set = 1
repeated shape_and_type = 2
Only valid if <is_set>.
message
cpp_shape_inference.proto:13Used in:
optional shape = 1
DataType dtype = 2
optional type = 4
message
master.proto:39Used as request type in: grpc.MasterService.CreateSession
Used as field type in:
optional graph_def = 1
The initial graph definition.
optional config = 2
Configuration options.
string target = 3
The target string used from the client's perspective.
message
master.proto:50Used as response type in: grpc.MasterService.CreateSession
Used as field type in:
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.
message
worker.proto:60Used as request type in: grpc.WorkerService.CreateWorkerSession
string session_handle = 1
Sessions are identified by a given handle.
optional 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.
repeated cluster_device_attributes = 4
The device attributes of all the devices in the cluster.
string master_task = 5
The master task name from which the request is sent.
int64 master_incarnation = 6
The incarnation ID of the master task local CPU device. If the target worker already has a WorkerSession created previously with the same master task name but a different incarnation, it usually indicates that the previous master failed before deleting the WorkerSession on the worker. To prevent memory leaks, the worker should garbage collect the old WorkerSessions.
message
worker.proto:88Used as response type in: grpc.WorkerService.CreateWorkerSession
(message has no fields)
message
critical_section.proto:12Protocol buffer representing a CriticalSection.
string critical_section_name = 1
Name of the critical section handle.
message
critical_section.proto:18Protocol 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).
message
autotuning.proto:16Used in: ,
int32 major = 1
int32 minor = 2
int32 patch = 3
Used in:
DATA_CLASS_UNKNOWN = 0
Unknown data class, used (implicitly) for legacy data. Will not be processed by data ingestion pipelines.
DATA_CLASS_SCALAR = 1
Scalar time series. Each `Value` for the corresponding tag must have `tensor` set to a rank-0 tensor of type `DT_FLOAT` (float32).
DATA_CLASS_TENSOR = 2
Tensor time series. Each `Value` for the corresponding tag must have `tensor` set. The tensor value is arbitrary, but should be small to accommodate direct storage in database backends: an upper bound of a few kilobytes is a reasonable rule of thumb.
DATA_CLASS_BLOB_SEQUENCE = 3
Blob sequence time series. Each `Value` for the corresponding tag must have `tensor` set to a rank-1 tensor of bytestring dtype.
(== suppress_warning documentation-presence ==) LINT.IfChange
Used in: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
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
message
debug_event.proto:69An Event related to the debugging of a TensorFlow program.
double wall_time = 1
Timestamp in seconds (with microsecond precision).
int64 step = 2
Step of training (if available).
oneof what
debug_metadata = 3
Metadata related to this debugging data.
source_file = 4
The content of a source file.
stack_frame_with_id = 6
A stack frame (filename, line number and column number, function name and code string) with ID.
graph_op_creation = 7
The creation of an op within a graph (e.g., a FuncGraph compiled from a Python function).
debugged_graph = 8
Information about a debugged graph.
execution = 9
Execution of an op or a Graph (e.g., a tf.function).
graph_execution_trace = 10
A graph execution trace: Contains information about the intermediate tensors computed during the graph execution.
string graph_id = 11
The ID of the graph (i.e., FuncGraph) executed here: applicable only to the execution of a FuncGraph.
debugged_device = 12
A device on which debugger-instrumented ops and/or tensors reside.
message
debug_event.proto:111Metadata about the debugger and the debugged TensorFlow program.
Used in:
string tensorflow_version = 1
Version of TensorFlow.
string file_version = 2
Version of the DebugEvent file format. Has a format of "debug.Event:<number>", e.g., "debug.Event:1".
string tfdbg_run_id = 3
A unique ID for the current run of tfdbg. A run of tfdbg is defined as a TensorFlow job instrumented by tfdbg. Multiple hosts in a distributed TensorFlow job instrumented by tfdbg have the same ID.
message
debug.proto:58Options for initializing DebuggerState in TensorFlow Debugger (tfdbg).
Used in: ,
repeated 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.
bool reset_disk_byte_usage = 11
Whether the total disk usage of tfdbg is to be reset to zero in this Session.run call. This is used by wrappers and hooks such as the local CLI ones to indicate that the dumped tensors are cleaned up from the disk after each Session.run.
message
debug.proto:12Option for watching a node in TensorFlow Debugger (tfdbg).
Used in:
string node_name = 1
Name of the node to watch. Use "*" for wildcard. But note: currently, regex is not supported in general.
int32 output_slot = 2
Output slot to watch. The semantics of output_slot == -1 is that all outputs of the node will be watched (i.e., a wildcard). Other negative values of output_slot are invalid and will lead to errors currently.
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.
message
debug_event.proto:219A device on which ops and/or tensors are instrumented by the debugger.
Used in:
string device_name = 1
Name of the device.
int32 device_id = 2
A debugger-generated ID for the device. Guaranteed to be unique within the scope of the debugged TensorFlow program, including single-host and multi-host settings. TODO(cais): Test the uniqueness guarantee in multi-host settings.
message
debug_event.proto:195A debugger-instrumented graph.
Used in:
string graph_id = 1
An ID for the graph. This can be used up to look up graph names. Generated by the debugger.
string graph_name = 2
Name of the graph (if available).
repeated string instrumented_ops = 3
Names of the instrumented ops. This can be used to look up op name based on the numeric-summary tensors (2nd column).
bytes original_graph_def = 4
Original (uninstrumented) GraphDef (if available).
bytes instrumented_graph_def = 5
An encoded version of a GraphDef. This graph may include the debugger-inserted ops.
string outer_context_id = 6
IDs of the immediate enclosing context (graph), if any.
message
debug.proto:74Used in:
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.
message
worker.proto:98Used as request type in: grpc.WorkerService.DeleteWorkerSession
string session_handle = 1
Sessions are identified by a given handle.
message
worker.proto:103Used as response type in: grpc.WorkerService.DeleteWorkerSession
(message has no fields)
message
worker.proto:175Used 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.
bool create_worker_session_called = 3
Set to true if `CreateWorkerSession` was called for `session_handle`.
string graph_handle = 1
REQUIRED: graph_handle must be returned by a RegisterGraph call to the same WorkerService.
message
worker.proto:188TODO(mrry): Optionally add summary stats for the graph.
Used as response type in: grpc.WorkerService.DeregisterGraph
(message has no fields)
message
device_attributes.proto:33Used in: , , , , , , , , ,
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 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.
int64 xla_global_id = 8
A physical device ID for use in XLA DeviceAssignments, unique across clients in a multi-client setup. Set to -1 if unavailable, non-negative otherwise.
message
device_attributes.proto:21Used in: , ,
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 links = 3
Optional local interconnect links to other devices.
message
device_properties.proto:24Used in: ,
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
message
step_stats.proto:79Used in:
string device = 1
repeated node_stats = 2
map<uint32, string> thread_names = 3
Its key is thread id.
message
struct.proto:93Represents a Python dict keyed by `str`. The comment on Unicode from Value.string_value applies analogously.
Used in:
map<string, > fields = 1
message
test_log.proto:14Used in:
oneof kind
double double_value = 1
string string_value = 2
message
event.proto:15Protocol 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:
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 = 5
A summary was generated.
log_message = 6
The user output a log message. This was theoretically used by the defunct tensorboard_logging module, which has since been removed; this field is now deprecated and should not be used.
session_log = 7
The state of the session which can be used for restarting after crashes.
tagged_run_metadata = 8
The metadata returned by running a session.run() call.
bytes meta_graph_def = 9
An encoded version of a MetaGraphDef.
message
debug_service.proto:28Reply 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 debug_op_state_changes = 1
optional 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.
message
debug_service.proto:29Used in:
DebugOpStateChange.State state = 1
string node_name = 2
int32 output_slot = 3
string debug_op = 4
Used in:
STATE_UNSPECIFIED = 0
DISABLED = 1
READ_ONLY = 2
READ_WRITE = 3
message
example.proto:88optional features = 1
map<string, > 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 = 1
string extra1 = 1337
int64 extra2 = 1338
fixed32 extra3 = 1339
fixed64 extra4 = 1340
double extra5 = 1341
repeated float extra6 = 1342
optional extra7 = 1343
message
debug_event.proto:233Data relating to the eager execution of an op or a Graph. For a op that generates N output tensors (N >= 0), only one Execution proto will be used to describe the execution event.
Used in:
string op_type = 1
Op type (e.g., "MatMul"). In the case of a Graph, this is the name of the Graph.
int32 num_outputs = 2
Number of output tensors.
string graph_id = 3
The graph that's executed: applicable only to the eager execution of a FuncGraph.
repeated int64 input_tensor_ids = 4
IDs of the input tensors (if available).
repeated int64 output_tensor_ids = 5
IDs of the output tensors (if availbable). If specified, must have the same length as tensor_protos.
TensorDebugMode tensor_debug_mode = 6
Type of the tensor value encapsulated in this proto.
repeated tensor_protos = 7
Output Tensor values in the type described by `tensor_value_type`. The length of this should match `num_outputs`.
optional code_location = 8
Stack trace of the eager execution.
repeated int32 output_tensor_device_ids = 9
Debugged-generated IDs of the devices on which the output tensors reside. To look up details about the device (e.g., name), cross-reference this field with the DebuggedDevice messages.
message
worker.proto:224Options specific to the execution of a single step.
Used in:
bool record_costs = 1
bool record_timeline = 3
bool record_partition_graphs = 4
bool report_tensor_allocations_upon_oom = 5
message
master.proto:80Used as request type in: grpc.MasterService.ExtendSession
Used as field type in:
string session_handle = 1
REQUIRED: session_handle must be returned by a CreateSession call to the same master service.
optional 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.
message
master.proto:96TODO(mrry): Return something about the operation?
Used as response type in: grpc.MasterService.ExtendSession
Used as field type in:
int64 new_graph_version = 4
The new version number for the extended graph, to be used in the next call to ExtendSession.
message
feature.proto:79Containers for non-sequential data.
Used in: ,
oneof kind
Each feature can be exactly one kind.
bytes_list = 1
float_list = 2
int64_list = 3
Used in:
oneof config
fixed_len_feature = 1
var_len_feature = 2
message
feature.proto:101Containers 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:
repeated feature = 1
message
feature.proto:105Used in:
map<string, > feature_list = 1
Map from feature name to feature list.
message
feature.proto:88Used in: , ,
map<string, > feature = 1
Map from feature name to feature.
message
fingerprint.proto:17Protocol buffer representing a SavedModel Fingerprint. If there are multiple MetaGraphDefs in the SavedModel, the FingerprintDef corresponds to the first one.
uint64 graph_def_checksum = 1
Hash of the graph_def, referred to as a "checksum".
uint64 graph_def_program_hash = 2
Hash of regularized graph_def.
uint64 signature_def_hash = 3
Hash of the regularized (sorted) SignatureDefs.
uint64 saved_object_graph_hash = 4
Hash of the regularized SavedObjectGraph.
uint64 checkpoint_hash = 5
Hash of the checkpoint.
optional version = 6
Version specification of the fingerprint.
Used in:
DataType dtype = 1
optional shape = 2
optional default_value = 3
string values_output_tensor_name = 4
message
feature.proto:71Used in:
repeated float value = 1
message
full_type.proto:281Highly experimental and very likely to change. This encoding uses tags instead of dedicated messages for regularity. In particular the encoding imposes no restrictions on what the parameters of any type should be, which in particular needs to be true for type symbols.
Used in: , ,
FullTypeId type_id = 1
The principal type represented by this object. This may be a concrete type (Tensor, Dataset) a type variable (used for dependent types) a type symbol (Any, Union). See FullTypeId for details.
repeated args = 2
oneof attr
Literal values of this type object, if the type admits one. For example, a type variable admits a string attribute - its name. Shape-related types may admit int attributes - their static shape values. Fields for more data types to be added as needed.
string s = 3
int64 i = 4
TODO(mdan): list/tensor, map? Need to reconcile with TFT_RECORD, etc.
LINT.IfChange Experimental. Represents the complete type information of a TensorFlow value.
Used in:
TFT_UNSET = 0
The default represents an uninitialized values.
TFT_VAR = 1
Type variables may serve as placeholder for any other type ID in type templates. Examples: TFT_DATASET[TFT_VAR["T"]] is a Dataset returning a type indicated by "T". TFT_TENSOR[TFT_VAR["T"]] is a Tensor of n element type indicated by "T". TFT_TENSOR[TFT_VAR["T"]], TFT_TENSOR[TFT_VAR["T"]] are two tensors of identical element types. TFT_TENSOR[TFT_VAR["P"]], TFT_TENSOR[TFT_VAR["Q"]] are two tensors of independent element types.
TFT_ANY = 2
Wildcard type. Describes a parameter of unknown type. In TensorFlow, that can mean either a "Top" type (accepts any type), or a dynamically typed object whose type is unknown in context. Important: "unknown" does not necessarily mean undeterminable!
TFT_PRODUCT = 3
The algebraic product type. This is an algebraic type that may be used just for logical grouping. Not to confused with TFT_TUPLE which describes a concrete object of several elements. Example: TFT_DATASET[TFT_PRODUCT[TFT_TENSOR[TFT_INT32], TFT_TENSOR[TFT_FLOAT64]]] is a Dataset producing two tensors, an integer one and a float one.
TFT_NAMED = 4
Represents a named field, with the name stored in the attribute. Parametrization: TFT_NAMED[<type>]{<name>} * <type> is the type of the field * <name> is the field name, as string (thpugh can theoretically be an int as well) Example: TFT_RECORD[ TFT_NAMED[TFT_TENSOR[TFT_INT32]]{'foo'}, TFT_NAMED[TFT_TENSOR[TFT_FLOAT32]]{'bar'}, ] is a structure with two fields, an int tensor "foo" and a float tensor "bar".
TFT_FOR_EACH = 20
Template definition. Expands the variables by repeating a template as arguments of container. Parametrization: TFT_FOR_EACH[<container_type>, <template>, <expansions>] * <container_type> is the type of the container that the template will be expanded into * <template> is any type definition that potentially contains type variables * <expansions> is a TFT_VAR and may include more types in the future Example: TFT_FOR_EACH[ TFT_PRODUCT, TFT_TENSOR[TFT_VAR["t"]], TFT_VAR["t"] ] will substitute a T = TFT_INT32 to TFT_PRODUCT[TFT_TENSOR[TFT_INT32]] and a T = (TFT_INT32, TFT_INT64) to TFT_PRODUCT[TFT_TENSOR[TFT_INT32], TFT_TENSOR[TFT_INT64]].
TFT_CALLABLE = 100
Callable types describe functions and ops. Parametrization: TFT_CALLABLE[<arg type>, <return type>] * <arg type> is the type of the arguments; TFT_PRODUCT represents multiple arguments. * <return type> is the return type; TFT_PRODUCT represents multiple return values (that means that callables returning multiple things don't necessarily return a single tuple). Example: TFT_CALLABLE[ TFT_ANY, TFT_PRODUCT[TFT_TENSOR[TFT_INT32], TFT_TENSOR[TFT_FLOAT64]], ] is a callable with unspecified (for now) input arguments, and two return values of type tensor.
TFT_TENSOR = 1000
The usual Tensor. This is a parametric type. Parametrization: TFT_TENSOR[<element type>, <shape type>] * <element type> is currently limited to one of the element types defined below. * <shape type> is not yet defined, and may only be TFT_UNKNOWN for now. A TFT_SHAPE type will be defined in the future. Example: TFT_TENSOR[TFT_INT32, TFT_UNKNOWN] is a Tensor of int32 element type and unknown shape. TODO(mdan): Define TFT_SHAPE and add more examples.
TFT_ARRAY = 1001
Array (or tensorflow::TensorList in the variant type registry). Note: this is not to be confused with the deprecated `TensorArray*` ops which are not supported by FullType. This type represents a random-access list whose elements can be described by a single type. Although immutable, Array is expected to support efficient mutation semantics (i.e. element update) in the user-facing API. The element type may be generic or even TFT_ANY for a heterogenous list. Parametrization: TFT_ARRAY[<element type>] * <element type> may be any concrete type. Examples: TFT_ARRAY[TFT_TENSOR[TFT_INT32]] is a TensorArray holding int32 Tensors of any shape. TFT_ARRAY[TFT_TENSOR[TFT_UNKNOWN]] is a TensorArray holding Tensors of mixed element types. TFT_ARRAY[TFT_UNKNOWN] is a TensorArray holding any element type. TFT_ARRAY[] is equivalent to TFT_ARRAY[TFT_UNKNOWN]. TFT_ARRAY[TFT_ARRAY[]] is an array or arrays (of unknown types).
TFT_OPTIONAL = 1002
Optional (or tensorflow::OptionalVariant in the variant type registry). This type represents a value that may either hold an element of a single specified type, or nothing at all. Parametrization: TFT_OPTIONAL[<element type>] * <element type> may be any concrete type. Examples: TFT_OPTIONAL[TFT_TENSOR[TFT_INT32]] is an Optional holding an int32 Tensor of any shape.
TFT_LITERAL = 1003
Literal types describe compile-time constant values. Literal types may also participate in dependent types. Parametrization: TFT_LITERAL[<value type>]{<value>} * <value type> may be any concrete type compatible that can hold <value> * <value> is the type's attribute, and holds the actual literal value Examples: TFT_LITERAL[TFT_INT32]{1} is the compile-time constant 1.
TFT_ENCODED = 1004
Encoding types describe a value of a certain type, encoded as a different type. Parametrization: TFT_ENCODED[<encoded type>, <encoding type>] * <encoded type> may be any type * <encoding type> may be any type Examples: TFT_ENCODING[TFT_INT32, TFT_STRING] is an integer encoded as string.
TFT_BOOL = 200
The bool element type. TODO(mdan): Quantized types, legacy representations (e.g. ref)
TFT_UINT8 = 201
Integer element types.
TFT_UINT16 = 202
TFT_UINT32 = 203
TFT_UINT64 = 204
TFT_INT8 = 205
TFT_INT16 = 206
TFT_INT32 = 207
TFT_INT64 = 208
TFT_HALF = 209
Floating-point element types.
TFT_FLOAT = 210
TFT_DOUBLE = 211
TFT_BFLOAT16 = 215
TFT_COMPLEX64 = 212
Complex element types. TODO(mdan): Represent as TFT_COMPLEX[TFT_DOUBLE] instead?
TFT_COMPLEX128 = 213
TFT_STRING = 214
The string element type.
TFT_DATASET = 10102
Datasets created by tf.data ops and APIs. Datasets have generator/iterable semantics, that is, one can construct an iterator from them. Like Array, they are considered to return elements that can be described by a single type. Unlike Array, they do not support random access or mutation, and can potentially produce an infinite number of elements. A datasets can produce logical structures (e.g. multiple elements). This is expressed using TFT_PRODUCT. Parametrization: TFT_DATASET[<element type>]. * <element type> may be a concrete type or a type symbol. It represents the data type of the elements produced by the dataset. Examples: TFT_DATSET[TFT_TENSOR[TFT_INT32]] is a Dataset producing single int32 Tensors of unknown shape. TFT_DATSET[TFT_PRODUCT[TFT_TENSOR[TFT_INT32], TFT_TENSOR[TFT_FLOAT32]] is a Dataset producing pairs of Tensors, one integer and one float. Note: The high ID number is to prepare for the eventuality that Datasets will be supported by user types in the future.
TFT_RAGGED = 10103
A ragged tensor created by tf.ragged ops and APIs. Parametrization: TFT_RAGGED[<element_type>].
TFT_ITERATOR = 10104
Iterators created by tf.data ops and APIs. Very similar to Datasets, except they are mutable. Parametrization: TFT_ITERATOR[<element type>]. * <element type> may be a concrete type or a type symbol. It represents the data type of the elements produced by the dataset.
TFT_MUTEX_LOCK = 10202
A mutex lock tensor, produced by tf.raw_ops.MutexLock. Unlike strict execution models, where ownership of a lock is denoted by "running after the lock has been acquired", in non-strict mode, lock ownership is in the true sense: "the op argument representing the lock is available". Mutex locks are the dynamic counterpart of control dependencies. TODO(mdan): Properly document this thing. Parametrization: TFT_MUTEX_LOCK[].
TFT_LEGACY_VARIANT = 10203
The equivalent of a Tensor with DT_VARIANT dtype, kept here to simplify translation. This type should not normally appear after type inference. Note that LEGACY_VARIANT != ANY: TENSOR[INT32] is a subtype of ANY, but is not a subtype of LEGACY_VARIANT.
message
function.proto:28A 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: ,
optional signature = 1
The definition of the function's name, arguments, return values, attrs etc.
map<string, > attr = 5
Attributes specific to this function definition.
map<uint32, > arg_attr = 7
map<uint32, uint32> resource_arg_unique_id = 8
Unique IDs for each resource argument, used to track aliasing resources. If Argument A and Argument B alias each other, then resource_arg_unique_ids[A.index] == resource_arg_unique_ids[B.index]. If this field is empty, none of the arguments could alias; otherwise, every resource argument should have an entry in this field. When instantiated, the unique IDs will be attached to the _Arg nodes' "_resource_arg_unique_id" attribute.
repeated 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.
map<string, string> control_ret = 6
A mapping from control output names from `signature` to node names in `node_def` which should be control outputs of this function.
message
function.proto:38Attributes for function arguments. These attributes are the same set of valid attributes as to _Arg nodes.
Used in:
map<string, > attr = 1
message
function.proto:16A library is a set of named functions.
Used in: , ,
repeated function = 1
repeated gradient = 2
repeated registered_gradients = 3
message
saved_object_graph.proto:210Represents `FunctionSpec` used in `Function`. This represents a function that has been wrapped as a TensorFlow `Function`.
Used in: ,
optional fullargspec = 1
Full arg spec from inspect.getfullargspec().
bool is_method = 2
Whether this represents a class method.
optional input_signature = 5
The input signature, if specified.
FunctionSpec.JitCompile jit_compile = 6
Whether the function should be compiled by XLA. The public interface to `tf.function` uses an optional boolean to represent three distinct states for this field. Unfortunately, proto3 removes the ability to explicitly check for the presence or absence of a field, so we instead map to an enum. See `tf.function` for details.
Used in:
DEFAULT = 0
ON = 1
OFF = 2
message
test_log.proto:115string 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"
message
config.proto:19Used in:
double per_process_gpu_memory_fraction = 1
Fraction of the available GPU memory to allocate for each process. 1 means to allocate all of the GPU memory, 0.5 means the process allocates up to ~50% of the available GPU memory. GPU memory is pre-allocated unless the allow_growth option is enabled. If greater than 1.0, uses CUDA unified memory to potentially oversubscribe the amount of memory available on the GPU device by using host memory as a swap space. Accessing memory not available on the device will be significantly slower as that would require memory transfer between the host and the device. Options to reduce the memory requirement should be considered before enabling this option as this may come with a negative performance impact. Oversubscription using the unified memory requires Pascal class or newer GPUs and it is currently only supported on the Linux operating system. See https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#um-requirements for the detailed requirements.
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 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).
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 "platform 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 experimental = 9
Everything inside experimental is subject to change and is not subject to API stability guarantees in https://www.tensorflow.org/guide/version_compat.
message
config.proto:101Used in:
repeated 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 of the virtual devices determined by device_ordinal and the location in the virtual device list. For example, visible_device_list = "1,0" virtual_devices { memory_limit: 1GB memory_limit: 2GB } virtual_devices { memory_limit: 3GB memory_limit: 4GB } will create 4 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 3GB memory /device:GPU:3 -> visible GPU 0 with 4GB memory but visible_device_list = "1,0" virtual_devices { memory_limit: 1GB memory_limit: 2GB device_ordinal: 10 device_ordinal: 20} virtual_devices { memory_limit: 3GB memory_limit: 4GB device_ordinal: 10 device_ordinal: 20} will create 4 virtual devices as: /device:GPU:0 -> visible GPU 1 with 1GB memory (ordinal 10) /device:GPU:1 -> visible GPU 0 with 3GB memory (ordinal 10) /device:GPU:2 -> visible GPU 1 with 2GB memory (ordinal 20) /device:GPU:3 -> visible GPU 0 with 4GB memory (ordinal 20) 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.
bool use_unified_memory = 2
If true, uses CUDA unified memory for memory allocations. If per_process_gpu_memory_fraction option is greater than 1.0, then unified memory is used regardless of the value for this field. See comments for per_process_gpu_memory_fraction field for more details and requirements of the unified memory. This option is useful to oversubscribe memory if multiple processes are sharing a single GPU while individually using less than 1.0 per process memory fraction.
int32 num_dev_to_dev_copy_streams = 3
If > 1, the number of device-to-device copy streams to create for each GPUDevice. Default value is 0, which is automatically converted to 1.
string collective_ring_order = 4
If non-empty, defines a good GPU ring order on a single worker based on device interconnect. This assumes that all workers have the same GPU topology. Specify as a comma-separated string, e.g. "3,2,1,0,7,6,5,4". This ring order is used by the RingReducer implementation of CollectiveReduce, and serves as an override to automatic ring order generation in OrderTaskDeviceMap() during CollectiveParam resolution.
bool timestamped_allocator = 5
If true then extra work is done by GPUDevice and GPUBFCAllocator to keep track of when GPU memory is freed and when kernels actually complete so that we can know when a nominally free memory chunk is really not subject to pending use.
int32 kernel_tracker_max_interval = 7
Parameters for GPUKernelTracker. By default no kernel tracking is done. Note that timestamped_allocator is only effective if some tracking is specified. If kernel_tracker_max_interval = n > 0, then a tracking event is inserted after every n kernels without an event.
int32 kernel_tracker_max_bytes = 8
If kernel_tracker_max_bytes = n > 0, then a tracking event is inserted after every series of kernels allocating a sum of memory >= n. If one kernel allocates b * n bytes, then one event will be inserted after it, but it will count as b against the pending limit.
int32 kernel_tracker_max_pending = 9
If kernel_tracker_max_pending > 0 then no more than this many tracking events can be outstanding at a time. An attempt to launch an additional kernel will stall until an event completes.
double internal_fragmentation_fraction = 10
BFC Allocator can return an allocated chunk of memory upto 2x the requested size. For virtual devices with tight memory constraints, and proportionately large allocation requests, this can lead to a significant reduction in available memory. The threshold below controls when a chunk should be split if the chunk size exceeds requested memory size. It is expressed as a fraction of total available memory for the tf device. For example setting it to 0.05 would imply a chunk needs to be split if its size exceeds the requested memory by 5% of the total virtual device/gpu memory size.
bool use_cuda_malloc_async = 11
When true, use CUDA cudaMallocAsync API instead of TF gpu allocator.
bool disallow_retry_on_allocation_failure = 12
By default, BFCAllocator may sleep when it runs out of memory, in the hopes that another thread will free up memory in the meantime. Setting this to true disables the sleep; instead we'll OOM immediately.
message
config.proto:104Configuration for breaking down a visible GPU into multiple "virtual" devices.
Used in:
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.
repeated int32 priority = 2
Priority values to use with the virtual devices. Use the cuda function cudaDeviceGetStreamPriorityRange to query for valid range of values for priority. On a P4000 GPU with cuda 10.1, the priority range reported was 0 for least priority and -1 for greatest priority. If this field is not specified, then the virtual devices will be created with the default. If this field has values set, then the size of this must match with the above memory_limit_mb.
repeated int32 device_ordinal = 3
Virtual Device ordinal number determines the device ID of the device. A Virtual device with a lower ordinal number always receives the a smaller device id. The phyiscal device id and location in the virtual device list is used to break ties.
message
worker.proto:46Used as request type in: grpc.WorkerService.GetStatus
(message has no fields)
message
worker.proto:48Used as response type in: grpc.WorkerService.GetStatus
repeated device_attributes = 1
message
worker.proto:597Request for next agreed-upon step_id for the specified graph_keys. This is used to enable multiple graphs containing nodes from a common collective instance to coordinate using the same step_ids.
Used as request type in: grpc.WorkerService.GetStepSequence
repeated int64 graph_key = 1
message
worker.proto:607Next valid step_ids for one or more graph_keys.
Used as response type in: grpc.WorkerService.GetStepSequence
repeated step_sequence = 1
message
function.proto:124GradientDef 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:
string function_name = 1
The function name.
string gradient_func = 2
The gradient function's name.
message
graph_debug_info.proto:11repeated string files = 1
This stores all the source code file names and can be indexed by the `file_index`.
map<string, > traces = 2
This maps a node name to a stack trace in the source code. The map key is a mangling of the containing function and op name with syntax: op.name '@' func_name For ops in the top-level graph, the func_name is the empty string. Note that op names are restricted to a small number of characters which exclude '@', making it impossible to collide keys of this form. Function names accept a much wider set of characters. It would be preferable to avoid mangling and use a tuple key of (op.name, func_name), but this is not supported with protocol buffers.
message
graph_debug_info.proto:13This represents a file/line location in the source code.
Used in: ,
int32 file_index = 1
File name index, which can be used to retrieve the file name string from `files`. The value should be between 0 and (len(files)-1)
int32 line = 2
Line number in the file.
int32 col = 3
Col number in the file line.
string func = 4
Name of function contains the file line.
string code = 5
Source code contained in this file line.
message
graph_debug_info.proto:32This represents a stack trace which is a ordered list of `FileLineCol`.
Used in:
repeated file_line_cols = 1
Each line in the stack trace.
message
graph.proto:16Represents the graph of operations
Used in: , , , , , , , ,
repeated node = 1
optional 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 library = 2
"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.
message
debug_event.proto:277Data relating to an execution of a Graph (e.g., an eager execution of a FuncGraph). The values of the intermediate tensors computed in the graph are recorded in this proto. A graph execution may correspond to one or more pieces of `GraphExecutionTrace`, depending on whether the instrumented tensor values are summarized in an aggregated or separate fashion.
Used in:
string tfdbg_context_id = 1
Unique ID of the context that the executed op(s) belong to (e.g., a compiled concrete tf.function).
string op_name = 2
Name of the op (applicable only in the case of the `FULL_TENSOR` trace level).
int32 output_slot = 3
Output slot of the tensor (applicable only in the case of the `FULL_TENSOR` trace level).
TensorDebugMode tensor_debug_mode = 4
Type of the tensor value encapsulated in this proto.
optional tensor_proto = 5
Tensor value in the type described by `tensor_value_type`. This tensor may summarize the value of a single intermediate op of the graph, or those of multiple intermediate tensors.
string device_name = 6
Name of the device that the op belongs to.
message
debug_event.proto:164The creation of an op in a TensorFlow Graph (e.g., FuncGraph in TF2).
Used in:
string op_type = 1
Type of the op (e.g., "MatMul").
string op_name = 2
Name of the op (e.g., "Dense/MatMul_1").
string graph_name = 3
Name of the graph that the op is a part of (if available).
string graph_id = 4
Unique ID of the graph (generated by debugger). This is the ID of the immediately-enclosing graph.
string device_name = 5
Name of the device that the op is assigned to (if available).
repeated string input_names = 6
Names of the input tensors to the op.
int32 num_outputs = 7
Number of output tensors emitted by the op.
optional code_location = 8
The unique ID for code location (stack trace) of the op's creation.
repeated int32 output_tensor_ids = 9
Unique IDs for the output tensors of this op.
message
config.proto:307Used in: ,
bool enable_recv_scheduling = 2
If true, use control flow to schedule the activation of Recv nodes. (Currently ignored.)
optional 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 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).
message
graph_transfer_info.proto:26Used in:
string name = 1
int32 node_id = 2
repeated int64 shape = 3
bytes data = 4
DataType dtype = 5
message
graph_transfer_info.proto:41Used in:
string name = 1
repeated int64 shape = 2
DataType dtype = 3
message
graph_transfer_info.proto:47Used in:
string name = 1
repeated int64 shape = 2
DataType dtype = 3
message
graph_transfer_info.proto:56Protocol 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 node_info = 1
repeated const_node_info = 2
repeated node_input_info = 3
repeated node_output_info = 4
repeated graph_input_node_info = 5
Input Node parameters of transferred graph
repeated graph_output_node_info = 6
GraphTransferInfo.Destination destination = 7
Destination of graph transfer
Used in:
NOP = 0
HEXAGON = 1
message
graph_transfer_info.proto:17Used in:
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
message
graph_transfer_info.proto:13Used in:
int32 node_id = 1
int32 output_port = 2
message
graph_transfer_info.proto:33Used in:
int32 node_id = 1
repeated node_input = 2
message
graph_transfer_info.proto:37Used in:
int32 node_id = 1
repeated int32 max_byte_size = 2
message
histogram.proto:12Serialization format for histogram module in tsl/lib/histogram/histogram.h
Used in:
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
message
feature.proto:74Used in:
repeated int64 value = 1
message
device_attributes.proto:11Used in:
int32 device_id = 1
string type = 2
int32 strength = 3
message
cluster.proto:68Defines a single job in a TensorFlow cluster.
Used in:
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".
message
device_filters.proto:62Defines the device filters for tasks in a job.
Used in:
string name = 1
The name of this job.
map<int32, > tasks = 2
Mapping from task ID to task device filters.
message
kernel_def.proto:13Used in:
string op = 1
Must match the name of an Op.
string device_type = 2
Type of device this kernel runs on.
repeated 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.
int32 priority = 6
Prioritization of kernel amongst different devices. By default we assume priority is 0. The higher the priority the better. By default (i.e. if this is not set), we prefer GPU kernels over CPU.
message
kernel_def.proto:20Used in:
string name = 1
Name of an attr from the Op.
optional 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.
message
kernel_def.proto:46A collection of KernelDefs
repeated kernel = 1
message
coordination_service.proto:164Message for configuration key value. Key is structured like Unix file system, with multiple levels of directory names separated by the slash ('/') characters.
Used in: , , ,
string key = 1
bytes value = 2
message
worker.proto:428Used in:
int64 step_id = 1
optional step_stats = 2
message
master.proto:262Used as request type in: grpc.MasterService.ListDevices
Used as field type in:
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.
message
master.proto:274Used as response type in: grpc.MasterService.ListDevices
Used as field type in: ,
repeated local_device = 1
repeated remote_device = 2
message
struct.proto:82Represents a Python list.
Used in:
repeated values = 1
message
device_attributes.proto:17Used in:
repeated link = 1
message
event.proto:49Protocol buffer used for logging messages to the events file. This was theoretically used by the defunct tensorboard_logging module, which has been removed; this message is now deprecated and should not be used.
Used in:
LogMessage.Level level = 1
string message = 2
Used in:
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
message
op_performance_data.proto:64Used in:
double mu = 1
double sigma = 2
message
worker.proto:412Out-of-band request to begin or end logging, or to retrieve logs for particular steps.
Used as request type in: grpc.WorkerService.Logging
bool enable_rpc_logging = 1
If true, RPC logging will be enabled.
bool disable_rpc_logging = 4
If true, RPC logging will be disabled.
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.
message
worker.proto:433Used as response type in: grpc.WorkerService.Logging
repeated step = 1
message
test_log.proto:137Used in:
string hostname = 1
Host name of machine that ran the benchmark.
string serial_identifier = 7
Unique serial number of the machine.
optional platform_info = 2
Additional platform information.
optional cpu_info = 3
CPU Information.
repeated device_info = 4
Other devices that are attached and relevant (e.g. GPUInfo).
repeated available_device_info = 5
Devices accessible to the test (e.g. as given by list_local_devices).
optional memory_info = 6
message
master.proto:285Used as request type in: grpc.MasterService.MakeCallable
Used as field type in:
string session_handle = 1
REQUIRED: session_handle must be returned by a CreateSession call to the same master service.
optional options = 2
Options that define the behavior of the created callable.
int64 request_id = 3
Unique identifier for this request. Every MakeCallableRequest must have a unique request_id, and retried MakeCallableRequest must have the same request_id. If request_id is zero, retry detection is disabled.
message
master.proto:299Used as response type in: grpc.MasterService.MakeCallable
Used as field type in:
int64 handle = 1
A handle to the created callable.
message
worker.proto:395Message for managing the response cache maintained on the sender side. Currently only used by the gRPC worker service.
int64 request_id = 1
message
worker.proto:399(message has no fields)
message
conv_parameters.proto:83DataType ab_dtype = 1
DataType c_dtype = 2
bool trans_a = 3
bool trans_b = 4
uint64 m = 5
uint64 n = 6
uint64 k = 7
int64 lda = 8
int64 ldb = 9
int64 ldc = 10
stream_executor.dnn.ActivationMode activation_mode = 11
string device_identifier = 12
int32 version = 14
message
conv_autotuning.proto:35stream_executor.dnn.DataType ab_dtype = 1
stream_executor.dnn.DataType c_dtype = 2
bool trans_a = 3
bool trans_b = 4
uint64 m = 5
uint64 n = 6
uint64 k = 7
int64 lda = 8
int64 ldb = 9
int64 ldc = 10
stream_executor.dnn.ActivationMode activation = 11
int64 a_address = 12
int64 b_address = 13
int64 c_address = 14
int64 bias_address = 15
message
bfc_memory_map.proto:8Some of the data from AllocatorStats
Used in:
int64 num_allocs = 1
int64 bytes_in_use = 2
int64 peak_bytes_in_use = 3
int64 largest_alloc_size = 4
float fragmentation_metric = 5
message
bfc_memory_map.proto:16Used in:
uint64 address = 1
int64 size = 2
int64 requested_size = 3
int32 bin = 4
string op_name = 5
uint64 freed_at_count = 6
uint64 action_count = 7
bool in_use = 8
uint64 step_id = 9
message
memmapped_file_system.proto:29A directory of regions in a memmapped file.
repeated element = 1
message
memmapped_file_system.proto:22A message that describes one region of memmapped file.
Used in:
uint64 offset = 1
string name = 2
uint64 length = 3
message
bfc_memory_map.proto:41string allocator_name = 1
repeated bin_summary = 2
repeated chunk = 3
repeated snap_shot = 4
optional stats = 5
message
test_log.proto:110Used in:
int64 total = 1
Total virtual memory in bytes
int64 available = 2
Immediately available memory in bytes
message
log_memory.proto:57int64 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.
message
log_memory.proto:78int64 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.
message
log_memory.proto:13int64 step_id = 1
Process-unique step id.
string handle = 2
Handle describing the feeds and fetches of the step.
message
log_memory.proto:21int64 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 tensor = 3
Allocated tensor details.
message
log_memory.proto:33int64 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.
message
log_memory.proto:42int64 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 tensor = 4
Output tensor details.
message
step_stats.proto:44For memory tracking.
Used in:
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
message
meta_graph.proto:31Protocol 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:
optional meta_info_def = 1
optional graph_def = 2
GraphDef.
optional saver_def = 3
SaverDef.
map<string, > collection_def = 4
collection_def: Map from collection name to collections. See CollectionDef section for details.
map<string, > signature_def = 5
signature_def: Map from user supplied key for a signature to a single SignatureDef.
repeated asset_file_def = 6
Asset file def to be used with the defined graph.
optional object_graph_def = 7
Extra information about the structure of functions and stateful objects.
message
meta_graph.proto:34Meta 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:
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 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 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.
map<string, string> function_aliases = 8
FunctionDef name to aliases mapping.
message
test_log.proto:21Used in:
string name = 1
Metric name
double value = 2
Metric value
optional min_value = 3
The minimum acceptable value for the metric if specified
optional max_value = 4
The maximum acceptable value for the metric if specified
message
attr_value.proto:61A list of attr names and their values. The whole list is attached with a string name. E.g., MatMul[T=float].
Used in: , ,
string name = 1
map<string, > attr = 2
message
device_properties.proto:55string name = 1
optional properties = 2
message
named_tensor.proto:14A pair of tensor name and tensor values.
Used in: , , ,
string name = 1
Name of the tensor.
optional 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.
message
struct.proto:104Represents Python's namedtuple.
Used in:
string name = 1
repeated values = 2
message
replay_log.proto:12Records the creation of a new replay session. We record the device listing here to capture the state of the cluster.
Used in:
optional devices = 1
string session_handle = 2
message
node_def.proto:14Used in: , ,
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, > 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.
optional experimental_debug_info = 6
This stores debug information associated with the node.
optional experimental_type = 7
The complete type of this node. Experimental and subject to change. Currently, the field only contains the return types of the node. That will extend in the future to contain the entire signature of the node, as a function type.
message
node_def.proto:67Used in:
repeated string original_node_names = 1
Opaque string inserted into error messages created by the runtime. This is intended to store the list of names of the nodes from the original graph that this node was derived. For example if this node, say C, was result of a fusion of 2 nodes A and B, then 'original_node' would be {A, B}. This information can be used to map errors originating at the current node to some top level source code.
repeated string original_func_names = 2
This is intended to store the list of names of the functions from the original graph that this node was derived. For example if this node, say C, was result of a fusion of node A in function FA and node B in function FB, then `original_funcs` would be {FA, FB}. If the node is in the top level graph, the `original_func` is empty. This information, with the `original_node_names` can be used to map errors originating at the current ndoe to some top level source code.
message
step_stats.proto:55Time/size stats recorded for a single execution of a graph node.
Used in:
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 memory = 6
repeated output = 7
string timeline_label = 8
int64 scheduled_micros = 9
uint32 thread_id = 10
repeated referenced_tensor = 11
optional memory_stats = 12
int64 all_start_nanos = 13
int64 op_start_rel_nanos = 14
int64 op_end_rel_nanos = 15
int64 all_end_rel_nanos = 16
int64 scheduled_nanos = 17
message
step_stats.proto:38Output sizes recorded for a single execution of a graph node.
Used in:
int32 slot = 1
optional tensor_description = 3
message
struct.proto:79Represents None.
Used in:
(message has no fields)
message
op_performance_data.proto:59Used in:
double mu = 1
double sigma = 2
message
op_def.proto:19Defines 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: ,
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 input_arg = 2
Description of the input(s).
repeated output_arg = 3
Description of the output(s).
repeated string control_output = 20
Named control outputs for this operation. Useful only for composite operations (i.e. functions) which want to name different control outputs.
repeated attr = 4
optional 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.
bool is_distributed_communication = 21
Indicates whether the op implementation uses distributed communication. If True, the op is allowed to return errors for network disconnection and trigger TF network failure handling logics.
message
op_def.proto:25For describing inputs and outputs.
Used in:
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.
repeated handle_data = 7
The handle data for resource inputs.
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.
optional experimental_full_type = 17
Experimental. Full type declaration for this argument. The full type specification combines type, type_attr, type_list_attr, etc. into a unified representation. This declaration may contain non-concrete types (for example, Tensor<TypeVar<'T'>> is a valid type declaration. Note: this is a transient field. The long-term aim is to represent the entire OpDef as a single type: a callable. In that context, this field is just the type of a single argument.
message
op_def.proto:82Description 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:
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 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 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.
message
op_def.proto:182Information about version-dependent deprecation of an op
Used in:
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.
message
op_performance_data.proto:34Description of an operation as well as the parameters expected to impact its performance.
Used in:
string op = 1
The operation name. There may be custom parameters in attrs.
map<string, > attr = 2
Custom parameters impacting the behavior of the op.
repeated inputs = 3
repeated outputs = 5
Optional description of the op outputs
optional device = 4
Device on which the operation is run.
optional session_info = 6
Information about the session configs.
message
op_performance_data.proto:42Input data types, shapes and values if known.
Used in:
DataType dtype = 1
optional shape = 2
optional value = 3
message
op_def.proto:191A collection of OpDefs
Used in:
repeated op = 1
message
op_performance_data.proto:70Performance data for tensorflow operations
Used in:
optional op = 1
The op
optional 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.
execution_time_normal = 10
execution_time_log_normal = 11
optional op_memory = 9
message
op_performance_data.proto:106Memory usage data for a tensorflow operation.
Used in:
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
message
op_performance_data.proto:121A collection of OpPerformance data points.
repeated op_performance = 1
message
config.proto:250Options passed to the graph optimizer
Used in:
bool do_common_subexpression_elimination = 1
If true, optimize the graph using common subexpression elimination. Note: the optimization Level L1 will override this setting to true. So in order to disable common subexpression elimination the opt_level has to be set to L0.
bool do_constant_folding = 2
If true, perform constant folding optimization on the graph. Note: the optimization Level L1 will override this setting to true. So in order to disable constant folding the opt_level has to be set to L0.
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
bool cpu_global_jit = 7
CPU code will be autoclustered only if global_jit_level >= ON_1 and either: - this flag is true, or - TF_XLA_FLAGS contains --tf_xla_cpu_global_jit=true.
Control the use of the compiler/jit. Experimental.
Used in: ,
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:
L1 = 0
L1 is the default level. Optimization performed at L1 : 1. Common subexpression elimination 2. Constant folding
L0 = -1
No optimizations
message
struct.proto:98Represents a (key, value) pair.
Used in:
string key = 1
optional value = 2
message
master.proto:176Used as request type in: grpc.MasterService.PartialRunSetup
Used as field type in:
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.
int64 request_id = 5
Unique identifier for this request. Every PartialRunSetupRequest must have a unique request_id, and retried PartialRunSetupRequest must have the same request_id. If request_id is zero, retry detection is disabled.
message
master.proto:200Used as response type in: grpc.MasterService.PartialRunSetup
Used as field type in:
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.
message
test_log.proto:121Used in:
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'
message
profiler_options.proto:6Next ID: 11
Used in: ,
uint32 version = 5
Some default value of option are not proto3 default value. Use this version to determine if we should use default option value instead of proto3 default value.
ProfileOptions.DeviceType device_type = 6
Device type to profile/trace: (version >= 1) DeviceType::UNSPECIFIED: All registered device profiler will be enabled. DeviceType::CPU: only CPU will be profiled. DeviceType::GPU: only CPU/GPU will be profiled. DeviceType::TPU: only CPU/TPU will be profiled. DeviceType::PLUGGABLE_DEVICE: only CPU/pluggable devices with profilers will be profiled.
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.
uint32 host_tracer_level = 2
Levels of host tracing: (version >= 1) - Level 0 is used to disable host traces. - Level 1 enables tracing of only user instrumented (or default) TraceMe. - Level 2 enables tracing of all level 1 TraceMe(s) and instrumented high level program execution details (expensive TF ops, XLA ops, etc). This is the default. - Level 3 enables tracing of all level 2 TraceMe(s) and more verbose (low-level) program execution details (cheap TF ops, etc).
uint32 device_tracer_level = 3
Levels of device tracing: (version >= 1) - Level 0 is used to disable device traces. - Level 1 is used to enable device traces. - More levels might be defined for specific device for controlling the verbosity of the trace.
uint32 python_tracer_level = 4
Whether enable python function calls tracing. Runtime overhead ensues if enabled. Default off. (version >= 1)
bool enable_hlo_proto = 7
Whether serialize hlo_proto when XLA is used. (version >= 1)
uint64 start_timestamp_ns = 8
The local profiler starts profiling at this Unix timestamp in nanoseconds.
uint64 duration_ms = 9
The local profiler collects `duration_ms` milliseconds of data. If the value is 0, profiling continues until interrupted.
string repository_path = 10
Directory to save profile data to. No-op when empty.
Used in:
UNSPECIFIED = 0
CPU = 1
GPU = 2
TPU = 3
PLUGGABLE_DEVICE = 4
message
profiler_service.proto:33Next-ID: 9
Used as request type in: ProfilerService.Profile
Used as field type in:
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, > tool_options = 8
Specifies the requirement for each tools.
optional 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/plugins/profile/ as the 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.
message
profiler_analysis.proto:28Used in:
string session_id = 1
repeated string available_tools = 2
Which tool data is available for consumption.
message
profiler_service.proto:67Used in:
string name = 1
The file name which this data is associated (e.g. "input_pipeline.json", "cluster_xxx.memory_viewer.json").
bytes data = 2
The data payload (likely json) for the specific tool.
Used in:
ProfilerServiceMonitorResult.ResponseType response_type = 1
Type of profiling responses.
double device_idle_time_percent = 2
Percentage of time when device is idle.
double matrix_unit_utilization_percent = 3
TPU matrix unit utilization percentage.
double step_time_ms_avg = 4
Average step time in millisecond.
double step_time_ms_min = 5
Minimum step time in millisecond.
double step_time_ms_max = 6
Maximum step time in millisecond.
double infeed_percent_avg = 7
Average infeed percentage.
double infeed_percent_min = 8
Minimum infeed percentage.
double infeed_percent_max = 9
Maximum infeed percentage.
Represents the different types of responses from the profiling service.
Used in:
EMPTY_RESULT = 0
No result is returned from the profiling service.
UTIL_ONLY = 1
Only device utilization is available.
UTIL_IDLE = 2
Both device utilization and device idle time are available.
UTIL_IDLE_STEP = 3
Device utilization, device idle time, step time, and infeed percentage are all available.
message
queue_runner.proto:14Protocol 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.
message
config.proto:379Used in:
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.
string compression_algorithm = 2
The compression algorithm to be used. One of "deflate", "gzip".
int32 compression_level = 3
If compression_algorithm is set, the compression level to be used. From 0 (no compression), up to 3.
bool cache_rpc_response = 4
Setting cache_rpc_response to true will enable sender side caching of response for RecvTensorAsync and RecvBufAsync to allow receiver to retry requests . This is only necessary when the network fabric is experiencing a significant error rate. Without it we'll fail a step on an network error, while with it we'll be able to complete long steps (like complex initializations) in the face of some network errors during RecvTensor.
bool disable_session_connection_sharing = 5
Disables TCP connection sharing when opening a new RPC channel.
int32 num_channels_per_target = 6
Setting num_channels_per_target > 0 allows uses of multiple channels to communicate to the same target. This can be used to improve the aggregate throughput on high speed links (e.g 100G) where single connection is not sufficient to maximize link utilization. Note that a single RPC only goes on a single channel, this only helps in situations where there are multiple transfers to the same target overlapping in time.
message
reader_base.proto:13For 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
message
worker.proto:481Use of the fields below may vary by implementation. For example the buf_ptr and num_bytes may be set only for local operations and not sent on the wire, or only sent on the wire in one direction.
Used as request type in: grpc.WorkerService.RecvBuf
int64 step_id = 1
Used at server side to find the correct BufRendezvous.
string buf_rendezvous_key = 2
Arbitrary string identifying a BufRendezvous entry.
int64 num_bytes = 3
Size of value expected, must agree with BufRendezvous entry.
fixed64 buf_ptr = 4
When RDMA is in use, address of destination field on client.
optional client_locality = 5
Optional information on client-side device locality.
optional server_locality = 6
Optional information on server-side device locality.
optional transport_options = 7
Optional, implementation-specific data.
string src_device = 8
For annotating timeline and device incarnation check.
string dst_device = 9
Optional, for annotating the timeline.
int64 request_id = 10
Depending on the RPC system in use, it may be necessary to set this id to detect resends of RPCs where the server is not aware that the prior RPC failed.
uint64 src_incarnation = 11
Incarnation number of the source device, used to detect worker failures.
message
transport_options.proto:8Extra data needed on a non-RDMA RecvBufResponse.
repeated bytes tensor_content = 1
message
worker.proto:520Use of the fields below may vary by implementation. Comments give intended use.
Used as response type in: grpc.WorkerService.RecvBuf
fixed64 buf_ptr = 1
Address of source field on server.
int64 num_bytes = 2
Byte length of buf_ptr field, if set.
bool is_dead = 3
True if value is 'dead' like a tensor.
optional transport_options = 4
Optional, implementation-specific data.
int64 send_start_micros = 5
Optional, for timeline.
bool require_ack = 6
Whether the receiver should send a MarkRecvFinishedRequest to the sender to ack the message.
message
worker.proto:335Used 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 client_locality = 4
Optional information on client-side device locality.
optional server_locality = 5
Optional information on server-side device locality.
optional 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 and response cache are 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.
message
worker.proto:373Used as response type in: grpc.WorkerService.RecvTensor
optional 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 transport_options = 4
Optional additional information about how to receive the tensor, e.g. in the event that `RecvTensorRequest.dma_ok` was true.
bool require_ack = 5
Whether the receiver should send a MarkRecvFinishedRequest to the sender to ack the message.
message
worker.proto:119Used as request type in: grpc.WorkerService.RegisterGraph
string session_handle = 1
Subgraphs are scoped within one session.
bool create_worker_session_called = 6
Set to true if `CreateWorkerSession` was called for `session_handle`.
optional 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 graph_options = 4
Configuration options for the session in which this graph was created.
optional debug_options = 5
Field(s) used by TensorFlow Debugger (tfdbg).
int64 collective_graph_key = 7
If graph_def contains any collective ops this must be a positive integer used to coordinate execution with other graphs. All graphs in a distributed execution with the same collective_graph_key will coordinate to use the same step_id concurrently so that BufRendezvous entries will make the correct values accessible.
optional config_proto = 8
ConfigProto from the session in which this graph was created. Contains additional parameters beyond graph_options, including the name of the requested executor.
message
worker.proto:155Used 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.
message
function.proto:133RegisteredGradient stores a gradient function that is registered in the gradients library and used in the ops of a function in the function library. Unlike GradientDef, these gradients are identified by op type, and not directly linked to any function.
Used in:
string gradient_func = 1
The gradient function's name.
string registered_op_type = 2
The gradient function's registered op type.
message
trackable_object_graph.proto:74Used in:
string name = 1
The name of the registered saver/restore function.
string object_name = 2
Unique auto-generated name of the object.
message
master.proto:343Used as request type in: grpc.MasterService.ReleaseCallable
Used as field type in:
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.
message
master.proto:353Used as response type in: grpc.MasterService.ReleaseCallable
Used as field type in:
(message has no fields)
message
profiler_options.proto:70Options for remote profiler session manager. Next ID: 6
optional profiler_options = 1
Options for each local profiler.
repeated string service_addresses = 2
List of servers to profile. Supported formats: host:port.
uint64 session_creation_timestamp_ns = 3
Unix timestamp of when the session was started.
uint64 max_session_duration_ms = 4
Maximum time (in milliseconds) a profiling session manager waits for all profilers to finish after issuing gRPC request. If value is 0, session continues until interrupted. Otherwise, value must be greater than profiler_options.duration_ms.
uint64 delay_ms = 5
Start of profiling is delayed by this much (in milliseconds).
message
replay_log.proto:17double start_time_us = 31
double end_time_us = 32
oneof op
create_session = 1
extend_session = 2
partial_run_setup = 3
run_step = 4
close_session = 5
list_devices = 6
reset_request = 7
make_callable = 8
run_callable = 9
release_callable = 10
new_replay_session = 11
oneof response
create_session_response = 21
extend_session_response = 22
partial_run_setup_response = 23
run_step_response = 24
close_session_response = 25
list_devices_response = 26
reset_request_response = 27
make_callable_response = 28
run_callable_response = 29
release_callable_response = 30
message
event.proto:116Used in:
int32 exit_code = 1
message
master.proto:235Reset() 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
Used as field type in:
repeated string container = 1
A list of container names, which may be empty. 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.
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.
message
master.proto:251Used as response type in: grpc.MasterService.Reset
Used as field type in:
(message has no fields)
message
resource_handle.proto:17Protocol 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:
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.
repeated dtypes_and_shapes = 6
Data types and shapes for the underlying resource.
message
resource_handle.proto:36Protocol buffer representing a pair of (data type, tensor shape).
Used in: ,
DataType dtype = 1
optional shape = 2
message
rewriter_config.proto:24Graph rewriting is experimental and subject to change, not covered by any API stability guarantees.
Used in:
RewriterConfig.CpuLayout cpu_layout_conversion = 50
CPU Conversion settings between NHCW and NCHW.
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 shape_optimization = 13
Shape optimizations (default is ON) Simplify computations made on shapes.
RewriterConfig.Toggle remapping = 14
Remapping (default is ON) Remap subgraphs onto more efficient implementations.
RewriterConfig.Toggle common_subgraph_elimination = 24
Common subgraph elimination (default is ON) e.g. Simplify arithmetic ops; merge ops with same value (like 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.Toggle scoped_allocator_optimization = 15
Try to allocate some independent Op outputs contiguously in order to merge or eliminate downstream Ops (off by default).
RewriterConfig.Toggle pin_to_host_optimization = 18
Force small ops onto the CPU (default is OFF).
RewriterConfig.Toggle implementation_selector = 22
Enable the swap of kernel implementations based on the device placement (default is ON).
RewriterConfig.Toggle auto_mixed_precision = 23
Optimize data types for CUDA (default is OFF). This will try to use float16 on GPU which is faster. Note that this can change the numerical stability of the graph and may require the use of loss scaling to maintain model convergence.
RewriterConfig.Toggle auto_mixed_precision_mkl = 25
Optimize data types for oneDNN (default is OFF). This will try to use bfloat16 on CPUs, which is faster. Note that this can change the numerical stability of the graph. Note: this is deprecated. It is replaced by auto_mixed_precision_onednn_bfloat16
RewriterConfig.Toggle auto_mixed_precision_onednn_bfloat16 = 31
Optimize data types for oneDNN (default is OFF). This will try to use bfloat16 on CPUs, which is faster. Note that this can change the numerical stability of the graph. Note: this is equivalent to the deprecated option auto_mixed_precision_mkl
RewriterConfig.Toggle auto_mixed_precision_cpu = 29
Emulate a model using data type float16 on CPU (default is OFF). This will try to emulate the float16 inputs and outputs of an operator on CPU to have better correlation with float16 on GPU; however the computation in the operator is based on float32. Note that this can change the numerical stability of the graph.
bool disable_meta_optimizer = 19
Disable the entire meta optimizer (off by default).
RewriterConfig.Toggle use_plugin_optimizers = 28
Optimizers registered by plugin (default is ON)
RewriterConfig.Toggle experimental_conditional_code_motion = 30
Conditional code motion (default is ON).
RewriterConfig.NumIterationsType meta_optimizer_iterations = 12
Controls how many times we run the optimizers in meta optimizer (default is once).
int32 min_graph_nodes = 17
The minimum number of nodes in a graph to optimizer. For smaller graphs, optimization is skipped. 0 means the system picks an appropriate number. < 0 means do not skip optimization.
bool experimental_disable_compressed_tensor_optimization = 26
Disable optimizations that assume compressed tensors. Note that this flag is experimental and may be removed in the future.
bool experimental_disable_folding_quantization_emulation = 27
Disable folding quantization emulation ops such as FakeQuantWithMinMax* and QuantizeAndDequantize*. Some compilers (e.g. the TF-to-tflite converter) have to extract quantization configs (e.g. min/max range, number of bits, and per-channel) from the quantization emulation ops. Note that this flag is experimental and may be removed in the future. See b/174138564 for more details.
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 recomputations. 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/"
int64 meta_optimizer_timeout_ms = 20
Maximum number of milliseconds to spend optimizing a single graph before timing out. If less than or equal to 0 (default value) the optimizer will never time out.
optional auto_parallel = 5
Configures AutoParallel optimization passes either through the meta-optimizer or when manually specified through the optimizers field.
bool fail_on_optimizer_errors = 21
If true, any optimization pass failing will cause the MetaOptimizer to stop with an error. By default - or when set to false, failing passes are skipped silently.
optional scoped_allocator_opts = 16
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 optimizers (see custom_optimizers) that are not part of this schedule will be run after - in the order that they were specified.
repeated custom_optimizers = 200
list of CustomGraphOptimizers to apply.
optional inter_optimizer_verifier_config = 300
VerifierConfig specifying the verifiers to be run after every optimizer.
optional post_optimization_verifier_config = 301
VerifierConfig specifying the verifiers to be run at the end, after all optimizers have run.
Enum for layout conversion between NCHW and NHWC on CPU. Default is OFF.
Used in:
NO_CONVERSION_ON_CPU = 0
NCHW_TO_NHWC = 1
NHWC_TO_NCHW = 2
message
rewriter_config.proto:225Message to describe custom graph optimizer and its parameters
Used in:
string name = 1
map<string, > parameter_map = 2
Used in:
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 controlling the number of times to run optimizers. The default is to run them twice.
Used in:
DEFAULT_NUM_ITERS = 0
ONE = 1
TWO = 2
Used in:
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.
EXPERIMENTAL_MLIR = 4
Run MLIR pass if there's one implemented in TFG, do nothing otherwise. I.e., if there's no corresponding TFG pass, it's an OFF. This is supposed to be mapped with `ON` and there's no `AGGRESSIVE` in MLIR pass now.
EXPERIMENTAL_BOTH = 5
Run both MLIR and Grappler passes consecutively and MLIR pass will come first.
message
master.proto:310Used as request type in: grpc.MasterService.RunCallable
Used as field type in:
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 feed = 3
Values of the tensors passed as arguments to the callable, in the order defined in the CallableOptions.feed field passed to MakeCallable.
int64 request_id = 4
Unique identifier for this request. Every RunCallableRequest must have a unique request_id, and retried RunCallableRequest must have the same request_id. If request_id is zero, retry detection is disabled.
message
master.proto:328Used as response type in: grpc.MasterService.RunCallable
Used as field type in:
repeated fetch = 1
Values of the tensors returned by the callable, in the order defined in the CallableOptions.fetch field passed to MakeCallable.
optional metadata = 2
Returned metadata if requested in the options.
message
test_log.proto:160Run-specific items such as arguments to the test / benchmark.
Used in:
repeated string argument = 1
map<string, string> env_vars = 2
Environment variables used to run the test/benchmark.
message
worker.proto:231Used 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.
bool create_worker_session_called = 10
Set to true if `CreateWorkerSession` was called for `session_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 exec_opts = 5
Options for this step.
repeated 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.
int64 request_id = 11
Unique identifier for this request. Every RunGraphRequest must have a unique request_id, and retried RunGraphRequests must have the same request_id. If request_id is zero, retry detection is disabled. Retried RunGraphRequests are problematic because they may issue a RecvTensor that will have no corresponding sender and will wait forever. Workers use request_ids to reject retried RunGraph requests instead of waiting forever.
message
worker.proto:288Used as response type in: grpc.WorkerService.RunGraph
repeated recv = 1
A list of tensors corresponding to those requested by `RunGraphRequest.recv_key`.
optional 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 cost_graph = 3
repeated 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
message
config.proto:792Metadata output (i.e., non-Tensor) for a single Run() call.
Used in: ,
optional 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 cost_graph = 2
The cost graph for the computation defined by the run call.
repeated partition_graphs = 3
Graphs of the partitions executed by executors.
repeated function_graphs = 4
This is only populated for graphs that are run as functions in TensorFlow V2. There will be an entry below for each function that is traced. The main use cases of the post_optimization_graph and the partition_graphs is to give the caller insight into the graphs that were actually run by the runtime. Additional information (such as those in step_stats) will match these graphs. We also include the pre_optimization_graph since it is usually easier to read, and is helpful in situations where the caller wants to get a high level idea of what the built graph looks like (since the various graph optimization passes might change the structure of the graph significantly).
optional session_metadata = 5
Metadata about the session.
message
config.proto:804Used in:
repeated partition_graphs = 1
TODO(nareshmodi): Include some sort of function/cache-key identifier?
optional pre_optimization_graph = 2
optional post_optimization_graph = 3
message
config.proto:727Options for a single Run() call.
Used in: ,
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. To use the caller thread set this to -1 - this uses the caller thread to execute Session::Run() and thus avoids a context switch. Using the caller thread to execute Session::Run() should be done ONLY for simple graphs, where the overhead of an additional context switch is comparable with the overhead of Session::Run().
bool output_partition_graphs = 5
Whether the partition graph(s) executed by the executor(s) should be outputted via RunMetadata.
optional 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.
optional experimental = 8
message
config.proto:766Everything inside Experimental is subject to change and is not subject to API stability guarantees in https://www.tensorflow.org/guide/version_compat.
Used in:
int64 collective_graph_key = 1
If non-zero, declares that this graph is going to use collective ops and must synchronize step_ids with any other graph with this same group_key value (in a distributed computation where tasks run disjoint graphs).
bool use_run_handler_pool = 2
If true, then operations (using the inter-op pool) across all session::run() calls will be centrally scheduled, optimizing for (median and tail) latency. Consider using this option for CPU-bound workloads like inference.
optional run_handler_pool_options = 3
message
config.proto:778Options for run handler thread pool.
Used in:
int64 priority = 1
Priority of the request. The run handler thread pool will schedule ops based on the priority number. The larger number means higher priority.
TODO(pbar) Turn this into a TraceOptions proto which allows tracing to be controlled in a more orthogonal manner?
Used in:
NO_TRACE = 0
SOFTWARE_TRACE = 1
HARDWARE_TRACE = 2
FULL_TRACE = 3
message
master.proto:113Used as request type in: grpc.MasterService.RunStep
Used as field type in:
string session_handle = 1
REQUIRED: session_handle must be returned by a CreateSession call to the same master service.
repeated 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 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.
int64 request_id = 8
Unique identifier for this request. Every RunStepRequest must have a unique request_id, and retried RunStepRequest must have the same request_id. If request_id is zero, retry detection is disabled.
message
master.proto:150Used as response type in: grpc.MasterService.RunStep
Used as field type in:
repeated tensor = 1
NOTE: The order of the returned tensors may or may not match the fetch order specified in RunStepRequest.
optional 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
message
variable.proto:75Used in:
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.
message
saved_object_graph.proto:246Used in:
int32 save_function = 2
Node ids of concrete functions for saving and loading from a checkpoint. These functions save and restore directly from tensors.
int32 restore_function = 3
message
saved_object_graph.proto:131A SavedAsset points to an asset in the MetaGraph. When bound to a function this object evaluates to a tensor with the absolute filename. Users should not depend on a particular part of the filename to remain stable (e.g. basename could be changed).
Used in:
int32 asset_file_def_index = 1
Index into `MetaGraphDef.asset_file_def[]` that describes the Asset. Only the field `AssetFileDef.filename` is used. Other fields, such as `AssetFileDef.tensor_info`, MUST be ignored.
message
saved_object_graph.proto:167Used in:
string concrete_function_name = 1
Identifies a SavedConcreteFunction.
repeated string argument_keywords = 2
A sequence of unique strings, one per Tensor argument.
int64 allowed_positional_arguments = 3
The prefix of `argument_keywords` which may be identified by position.
optional function_spec = 4
The spec of the function that this ConcreteFunction is traced from. This allows the ConcreteFunction to be called with nest structure inputs. This field may not be populated. If this field is absent, the concrete function can only be called with flat inputs. TODO(b/169361281): support calling saved ConcreteFunction with structured inputs in C++ SavedModel API.
message
saved_object_graph.proto:155Stores low-level information about a concrete function. Referenced in either a SavedFunction or a SavedBareConcreteFunction.
Used in:
repeated int32 bound_inputs = 2
optional canonicalized_input_signature = 3
Input in canonicalized form that was received to create this concrete function.
optional output_signature = 4
Output that was the return value of this function after replacing all Tensors with TensorSpecs. This can be an arbitrary nested function and will be used to reconstruct the full structure from pure tensors.
message
saved_object_graph.proto:184Used in:
string operation = 1
An Operation name for a ConstantOp in this SavedObjectGraph's MetaGraph.
message
saved_object_graph.proto:140A function with multiple signatures, possibly with non-Tensor arguments.
Used in:
repeated string concrete_functions = 1
optional function_spec = 2
message
saved_model.proto:15SavedModel 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 meta_graphs = 2
One or more MetaGraphs.
message
saved_object_graph.proto:37Used in:
repeated children = 1
Objects which this object depends on: named edges in the dependency graph. Note: All kinds of SavedObject may have children, except "constant" and "captured_tensor".
repeated dependencies = 15
Ordered list of dependencies that must be loaded before this object. SavedModel loads with the bottom-up approach, by first creating all objects (in the order defined by the dependencies), then connecting the edges.
repeated slot_variables = 3
Slot variables owned by this object. This describes the three-way (optimizer, variable, slot variable) relationship; none of the three depend on the others directly. Note: currently only valid if kind == "user_object".
oneof kind
user_object = 4
asset = 5
function = 6
variable = 7
bare_concrete_function = 8
constant = 9
resource = 10
captured_tensor = 12
map<string, > saveable_objects = 11
Stores the functions used to save and restore this object. At most one of `saveable_objects` or `registered_saver` is defined for each SavedObject. See the comment below for the difference between SaveableObject and registered savers.
string registered_name = 13
The name of the registered class of the form "{package}.{class_name}". This field is used to search for the registered class at loading time.
optional serialized_user_proto = 14
The user-generated proto storing metadata for this object, to be passed to the registered classes's _deserialize_from_proto method when this object is loaded from the SavedModel.
string registered_saver = 16
String name of the registered saver. At most one of `saveable_objects` or `registered_saver` is defined for each SavedObject.
message
saved_object_graph.proto:25Used in:
repeated nodes = 1
Flattened list of objects in the object graph. The position of the object in this list indicates its id. Nodes[0] is considered the root node.
map<string, > concrete_functions = 2
Information about captures and output structures in concrete functions. Referenced from SavedBareConcreteFunction and SavedFunction.
message
saved_object_graph.proto:239A SavedResource represents a TF object that holds state during its lifetime. An object of this type can have a reference to a: create_resource() and an initialize() function.
Used in:
string device = 1
A device specification indicating a required placement for the resource creation function, e.g. "CPU". An empty string allows the user to select a device.
message
saved_tensor_slice.proto:61Saved tensor slice: it stores the name of the tensors, the slice, and the raw data.
Used in: ,
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 slice = 2
Extent of the slice. Must have one entry for each of the dimension of the tensor that this slice belongs to.
optional 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).
message
saved_tensor_slice.proto:34Metadata describing the set of slices of the same tensor saved in a checkpoint file.
Used in:
string name = 1
Name of the tensor.
optional shape = 2
Shape of the tensor
DataType type = 3
Type of the tensor
repeated slice = 4
Explicit list of slices saved in the checkpoint file.
message
saved_tensor_slice.proto:50Metadata describing the set of tensor slices saved in a checkpoint file. It is always stored at the beginning of each checkpoint file.
Used in: ,
repeated tensor = 1
Each SavedSliceMeta describes the slices for one tensor.
optional versions = 2
Compatibility version of this checkpoint. See core/public/version.h for version history.
message
saved_tensor_slice.proto:77Each record in a v3 checkpoint file is a serialized SavedTensorSlices message.
optional 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 data = 2
This exists in all but the first item of each checkpoint file.
message
saved_object_graph.proto:113A SavedUserObject is an object (in the object-oriented language of the TensorFlow program) of some user- or framework-defined class other than those handled specifically by the other kinds of SavedObjects. This object cannot be evaluated as a tensor, and therefore cannot be bound to an input of a function.
Used in:
string identifier = 1
Corresponds to a registration of the type to use in the loading program.
optional version = 2
Version information from the producer of this SavedUserObject.
string metadata = 3
Metadata for deserializing this object. Deprecated! At the time of deprecation, Keras was the only user of this field, and its saving and loading code will be updated shortly. Please save your application-specific metadata to a separate file.
message
saved_object_graph.proto:191Represents a Variable that is initialized by loading the contents from the checkpoint.
Used in:
DataType dtype = 1
optional shape = 2
bool trainable = 3
VariableSynchronization synchronization = 4
VariableAggregation aggregation = 5
string name = 6
string device = 7
repeated experimental_distributed_variable_components = 8
List of component variables for a distributed variable. When this field is non-empty, the SavedVariable will be assumed to be a distributed variable defined by the components listed here. This is only supported by experimental loaders at the moment.
message
saver.proto:12Protocol buffer representing the configuration of a Saver.
Used in:
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:
LEGACY = 0
Internal legacy format.
V1 = 1
Deprecated format: tf.Saver() which works with tensorflow::table::Table.
V2 = 2
Current format: more efficient.
message
rewriter_config.proto:19Used in:
repeated string enable_op = 1
If present, only perform optimization for these ops.
message
example.proto:298optional context = 1
optional feature_lists = 2
message
types.proto:80Represents a serialized tf.dtypes.Dtype
DataType datatype = 1
message
tensorflow_server.proto:31Defines the configuration of a single TensorFlow server.
Used in: , ,
optional 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 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", "grpc+verbs".
int32 port = 6
The server port. If not set, then we identify the port from the job_name.
optional cluster_device_filters = 7
Device filters for remote tasks in the cluster. NOTE: This is an experimental feature and only effective in TensorFlow 2.x.
message
op_performance_data.proto:28Description of the session when an op is run.
Used in: ,
int64 intra_op_parallelism = 1
message
event.proto:69Protocol buffer used for logging session state.
Used in:
SessionLog.SessionStatus status = 1
string checkpoint_path = 2
This checkpoint_path contains both the path and filename.
string msg = 3
Used in:
STATUS_UNSPECIFIED = 0
START = 1
STOP = 2
CHECKPOINT = 3
message
config.proto:422Metadata about the session. This can be used by the runtime and the Ops for debugging, monitoring, etc. The (name, version) tuple is expected to be a unique identifier for sessions within the same process. NOTE: This is currently used and propagated only by the direct session.
Used in: ,
string name = 1
int64 version = 2
The version is optional. If set, needs to be >= 0.
message
meta_graph.proto:314SignatureDef 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, in a MetaGraphDef message. 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:
map<string, > inputs = 1
Named input parameters.
map<string, > 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.
message
bfc_memory_map.proto:36Used in:
uint64 action_count = 1
int64 size = 2
message
debug_event.proto:128Content of a source file involved in the execution of the debugged TensorFlow program.
Used in:
string file_path = 1
Path to the file.
string host_name = 2
Name of the host on which the file is located.
repeated string lines = 3
Line-by-line content of the file.
message
debug_event.proto:140A stack frame with ID.
Used in:
string id = 1
A unique ID for the stack frame: A UUID-like string.
optional file_line_col = 2
Stack frame, i.e., a frame of a stack trace, containing information regarding the file name, line number, function name, code content of the line, and column number (if available).
message
worker.proto:601Used in:
int64 graph_key = 1
int64 next_step_id = 2
message
step_stats.proto:86Used in: , ,
repeated dev_stats = 1
message
struct.proto:35`StructuredValue` represents a dynamically typed value representing various data structures that are inspired by Python data structures typically used in TensorFlow functions as inputs and outputs. For example when saving a Layer there may be a `training` argument. If the user passes a boolean True/False, that switches between two concrete TensorFlow functions. In order to switch between them in the same way after loading the SavedModel, we need to represent "True" and "False". A more advanced example might be a function which takes a list of dictionaries mapping from strings to Tensors. In order to map from user-specified arguments `[{"a": tf.constant(1.)}, {"q": tf.constant(3.)}]` after load to the right saved TensorFlow function, we need to represent the nested structure and the strings, recording that we have a trace for anything matching `[{"a": tf.TensorSpec(None, tf.float32)}, {"q": tf.TensorSpec([], tf.float64)}]` as an example. Likewise functions may return nested structures of Tensors, for example returning a dictionary mapping from strings to Tensors. In order for the loaded function to return the same structure we need to serialize it. This is an ergonomic aid for working with loaded SavedModels, not a promise to serialize all possible function signatures. For example we do not expect to pickle generic Python objects, and ideally we'd stay language-agnostic.
Used in: , , , , , , ,
oneof kind
The kind of value.
none_value = 1
Represents None.
double float64_value = 11
Represents a double-precision floating-point value (a Python `float`).
sint64 int64_value = 12
Represents a signed integer value, limited to 64 bits. Larger values from Python's arbitrary-precision integers are unsupported.
string string_value = 13
Represents a string of Unicode characters stored in a Python `str`. In Python 3, this is exactly what type `str` is. In Python 2, this is the UTF-8 encoding of the characters. For strings with ASCII characters only (as often used in TensorFlow code) there is effectively no difference between the language versions. The obsolescent `unicode` type of Python 2 is not supported here.
bool bool_value = 14
Represents a boolean value.
tensor_shape_value = 31
Represents a TensorShape.
DataType tensor_dtype_value = 32
Represents an enum value for dtype.
tensor_spec_value = 33
Represents a value for tf.TensorSpec.
type_spec_value = 34
Represents a value for tf.TypeSpec.
bounded_tensor_spec_value = 35
Represents a value for tf.BoundedTensorSpec.
list_value = 51
Represents a list of `Value`.
tuple_value = 52
Represents a tuple of `Value`.
dict_value = 53
Represents a dict `Value`.
named_tuple_value = 54
Represents Python's namedtuple.
message
summary.proto:73A 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:
repeated value = 1
Set of values for the summary.
message
summary.proto:91Used in:
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
message
summary.proto:74Used in:
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.
message
summary.proto:104Used in:
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 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 = 4
histo = 5
audio = 6
tensor = 8
message
summary.proto:16Metadata 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"
message
summary.proto:24A SummaryMetadata encapsulates information on which plugins are able to make use of a certain summary value.
Used in:
optional 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.
DataClass data_class = 4
Class of data stored in this time series. Required for compatibility with TensorBoard's generic data facilities (`DataProvider`, et al.). This value imposes constraints on the dtype and shape of the corresponding tensor values. See `DataClass` docs for details.
message
summary.proto:25Used in:
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.
message
tpu_executable_info.proto:26A serialization of TPUExecutable. Only includes fields necessary to load and execute a program on a worker node.
repeated input_shapes = 2
The shapes of the inputs and outputs.
optional output_shape = 3
repeated dynamic_output_indices = 11
Dynamic output indices indicate which outputs have dynamic dimensions.
repeated variable_indices = 10
For each resource variable output, what was the index of the corresponding input and was it updated? The indices are sorted by input order.
repeated output_tensor_shapes = 8
The shapes of the outputs when represented as Tensors. These may not match the output_shape values because we may flatten tensors to avoid excess padding.
optional session_module = 5
Optional session module for passing XLA computations between TPUCompileOp and TPUExecuteOp. This is needed to support the --xla_dump_hlo_snapshots flag.
optional device_assignment = 6
The physical device ids assigned to the replicated cores.
message
tpu_executable_info.proto:39Used in:
repeated int32 index = 1
message
tpu_executable_info.proto:34Used in:
int32 index = 1
bool updated = 2
message
tpu_executable_info.proto:94repeated host_transfers = 1
message
tpu_executable_info.proto:67Metadata for a data transfer between device and host.
Used in:
int64 channel = 1
Channel identifier assigned by compiler and used in host commands.
TPUHostTransferProto.TransferDirection direction = 2
Direction of the transfer operation.
string key = 3
Channel identifier prodided by XLA client.
optional shape = 5
Shape of the data to be transferred (including layout).
int64 buffer_offset = 6
Address of the device buffer in HBM (byte offset).
xla.PrimitiveType original_type = 7
Original data type for this host transfer before X64 rewrite.
bool is_lower_bits = 8
If this host transfer is a splitted X64 transfer, specifies whether this transfer is for lower bits.
string host_handler_name = 9
The name of host side command handler.
Used in:
NONE = 0
DEVICE_TO_HOST = 1
HOST_TO_DEVICE = 2
message
event.proto:84For logging the metadata output for a single session.run() call.
Used in:
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.
message
device_filters.proto:57Defines the device filters for a remote task.
Used in:
repeated string device_filters = 1
message
config.proto:828Defines a connection between two tensors in a `GraphDef`.
Used in:
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`.
Available modes for extracting debugging information from a Tensor. TODO(cais): Document the detailed column names and semantics in a separate markdown file once the implementation settles.
Used in: ,
UNSPECIFIED = 0
NO_TENSOR = 1
Only records what tensors are computed, eagerly or in graphs. No information regarding the value of the tensor is available.
CURT_HEALTH = 2
A minimalist health summary for float-type tensors. Contains information only about the presence/absence of pathological values including Infinity and NaN. Applicable only to float dtypes.
CONCISE_HEALTH = 3
A concise health summary for float-type tensors. Contains more information that CURT_HEALTH. Infinity and NaN are treated differently. Applicable only to float and integer dtypes.
FULL_HEALTH = 4
A detailed health summary. Contains further detailed information than `CONCISE_HEALTH`. Information about device, dtype and shape are included. Counts for various types of values (Infinity, NaN, negative, zero, positive) are included. Applicable to float, integer and boolean dtypes.
SHAPE = 5
Provides full runtime shape information, up to a maximum rank, beyond which the dimension sizes are truncated.
FULL_NUMERICS = 6
Full numeric summary. Including device, dtype, shape, counts of various types of values (Infinity, NaN, negative, zero, positive), and summary statistics (minimum, maximum, mean and variance). Applicable to float, integer and boolean dtypes.
FULL_TENSOR = 7
Full tensor value.
REDUCE_INF_NAN_THREE_SLOTS = 8
Reduce the elements of a tensor to a rank-1 tensor of shape [3], in which - the 1st element is -inf if any element of the tensor is -inf, or zero otherwise. - the 2nd element is +inf if any element of the tensor is +inf, or zero otherwise. - the 3rd element is nan if any element of the tensor is nan, or zero otherwise.
message
tensor_description.proto:15Used in: , ,
DataType dtype = 1
Data type of tensor elements
optional shape = 2
Shape of the tensor.
optional allocation_description = 4
Information about the size and allocator used for the data
message
meta_graph.proto:214Information about a Tensor necessary for feeding or retrieval.
Used in: , ,
oneof encoding
string name = 1
For dense `Tensor`s, the name of the tensor in the graph.
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.
composite_tensor = 5
Generic encoding for CompositeTensors.
DataType dtype = 2
optional 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).
message
meta_graph.proto:231Generic encoding for composite tensors.
Used in:
optional type_spec = 1
The serialized TypeSpec for the composite tensor.
repeated components = 2
A TensorInfo for each flattened component tensor.
message
meta_graph.proto:217For sparse tensors, The COO encoding stores a triple of values, indices, and shape.
Used in:
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 [?].
message
tensor.proto:16Protocol buffer representing a tensor.
Used in: , , , , , , , , , , , , , , , , , , , , , , , , , ,
DataType dtype = 1
optional 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_UINT16, 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 resource_handle_val = 14
DT_RESOURCE
repeated variant_val = 15
DT_VARIANT
repeated uint32 uint32_val = 16
DT_UINT32
repeated uint64 uint64_val = 17
DT_UINT64
message
tensor_shape.proto:13Dimensions of a tensor.
Used in: , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , , ,
repeated 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.
message
tensor_shape.proto:15One dimension of the tensor.
Used in:
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.
message
tensor_slice.proto:14Can only be interpreted if you know the corresponding TensorShape.
Used in: , ,
repeated 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.
message
tensor_slice.proto:16Extent 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:
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
message
struct.proto:110A protobuf to represent tf.TensorSpec.
Used in:
string name = 1
optional shape = 2
DataType dtype = 3
message
tensor_tracer.proto:15Tensor Tracer Report proto gives information about the trace including: - TensorTracerConfig: version, device, num replicas, trace mode. - Graphdef, e.g., list of operations, tensors - TracedTensorDef: * Name of the tensor * Tracepoint name if provided. * Index of the tensor in the compact cache if traced. * Explanation for why the tensor is traced or not.
optional config = 1
optional graphdef = 2
Tensorflow graph.
map<string, > tensordef = 3
A map from tensor name to its TracedTensorDef.
string fingerprint = 4
The fingerprint of the TensorTracerReport (fingerprint calculation excludes this field and graphdef).
string concrete_function_name = 5
The function_name passed to the function_callback that produced this TensorTracerReport
int32 last_common_frame_no = 6
The index of the last stack frame where the stack traces for all output operations in the graph have the same value.
repeated string outputs = 7
List of names of output tensors of the function being traced.
optional tracing_stats = 8
Information about the number of tensors traced and skipped.
message
tensor_tracer.proto:42Used in:
string version = 1
Tensor tracer version, e.g. hostcall, outside compilation.
string device = 2
Traced device, CPU, TPU...
string trace_mode = 3
Trace mode, norm, summary, full-trace.
int32 num_cores = 4
Number of cores, e.g. TPU cores, in the system.
int32 num_hosts = 5
Number of hosts, e.g. compute nodes in the system.
string submode = 6
Keep submode as string for backward compatibility.
int32 num_cores_per_host = 7
Keep num cores per host for backward compatibility.
repeated int32 included_cores = 8
Id of the included cores, if a subset of cores are traced.
repeated string signatures = 9
The names of the signatures corresponding to the cache indices.
message
tensor_tracer.proto:81Used in:
string name = 1
Name of the tensor as appears in tf graph.
int32 cache_index = 2
Cache index of the tensor. This may be different than topological index.
string trace_point_name = 3
If trace points are provided, corresponding tracepoint name of the tensor. Trace points are placed on the edges (tensors) in the tensorflow graph, and they force tensor tracer to trace the corresponding tensor. Tracepoints can be added using the programatic interface tensor_tracer.tensor_tracepoint(tensor, trace_point_name) function. This will add a trace point with the given trace_point_name for the given tensor. If a trace_point is provided for the tensor, trace_point name will be used for the rest of the analysis instead of tensor names. One can use trace_point_name's to compare two models with arbitrary tensor names by providing the same trace point name for the tensors that are comparable.
bool is_traced = 4
Whether the tensor is traced or not.
string explanation = 5
Detailed explanation why the tensor is traced or not.
optional op_stack_info = 6
Detailed stack of operation
message
tensor_tracer.proto:105Used in:
repeated string stack_fn_names = 1
Function names from stack
repeated string stack_lines = 2
Line in stack
repeated string stack_filenames = 3
Filenames from stack
repeated int32 stack_linenos = 4
Line number in file from stack
message
tensor_tracer.proto:70Used in:
int32 total_tensors = 1
The total number of tensors in the function.
int32 traced_tensors = 2
The number of traced tensors in the function.
map<string, int32> traced_tensor_types = 3
Counts of traced tensors by op type.
int32 added_tensors = 4
The number of tensors added by Tensor Tracer.
message
test_log.proto:173The 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 entries = 2
The list of tests or benchmarks in this run.
optional build_configuration = 3
The configuration of the build (compiled opt? with cuda? any copts?)
optional 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 machine_configuration = 7
Machine-specific parameters (Platform and CPU info)
optional 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.
string tf_version = 12
TensorFlow version this benchmark runs against. This can be either set to full version or just the major version.
The type of benchmark.
Used in:
UNKNOWN = 0
Fallback for protos written before Type was introduced.
CPP_MICROBENCHMARK = 1
PYTHON_BENCHMARK = 2
ANDROID_BENCHMARK = 3
EDGE_BENCHMARK = 4
IOS_BENCHMARK = 5
message
callback.proto:10optional op = 1
repeated inputs = 2
repeated outputs = 3
message
callback.proto:11Used in: ,
optional shape = 1
optional DataType type = 2
message
callback.proto:16Used in:
optional buffer_description = 1
optional value = 2
The input value might be already fixed at the compilation time. This value may or may not be present.
message
callback.proto:24Used in:
optional buffer_description = 1
optional bool is_dynamically_padded = 2
Whether the buffer stores dynamically padded data: in that case, actual concrete dimensions need to be stored after the buffer.
message
coordination_service.proto:52Represent device information from different runtimes.
Used in:
repeated devices = 1
message
config.proto:354Used in:
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.
message
profiler_service.proto:21Used in:
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.
message
worker.proto:446Used in:
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.
message
worker.proto:464Out-of-band request to configure distributed tracing.
Used as request type in: grpc.WorkerService.Tracing
optional options = 1
message
worker.proto:468Used as response type in: grpc.WorkerService.Tracing
(message has no fields)
message
trackable_object_graph.proto:14repeated nodes = 1
message
trackable_object_graph.proto:15Used in:
repeated children = 1
Objects which this object depends on.
repeated attributes = 2
Serialized data specific to this object.
repeated slot_variables = 3
Slot variables owned by this object.
optional registered_saver = 4
The registered saver used to save this object. If this saver is not present when loading the checkpoint, then loading will fail.
optional has_checkpoint_values = 5
Whether this object has checkpoint values or descendants with checkpoint values. This is computed at save time to avoid traversing the entire object graph proto when restoring (which also has to traverse the live object graph).
message
trackable_object_graph.proto:16Used in: ,
int32 node_id = 1
An index into `TrackableObjectGraph.nodes`, indicating the object being referenced.
string local_name = 2
A user-provided name for the edge.
message
trackable_object_graph.proto:24Used in:
string name = 1
A name for the Tensor. Simple variables have only one `SerializedTensor` named "VARIABLE_VALUE" by convention. This value may be restored on object creation as an optimization.
string full_name = 2
The full name of the variable/tensor, if applicable. Used to allow name-based loading of checkpoints which were saved using an object-based API. Should match the checkpoint key which would have been assigned by tf.train.Saver.
string checkpoint_key = 3
The generated name of the Tensor in the checkpoint.
message
trackable_object_graph.proto:42Used in: ,
int32 original_variable_node_id = 1
An index into `TrackableObjectGraph.nodes`, indicating the variable object this slot was created for.
string slot_name = 2
The name of the slot (e.g. "m"/"v").
int32 slot_variable_node_id = 3
An index into `TrackableObjectGraph.nodes`, indicating the `Object` with the value of the slot variable.
message
struct.proto:87Represents a Python tuple.
Used in:
repeated values = 1
message
struct.proto:126Represents a tf.TypeSpec
Used in: , ,
TypeSpecProto.TypeSpecClass type_spec_class = 1
optional type_state = 2
The value returned by TypeSpec._serialize().
string type_spec_class_name = 3
The name of the TypeSpec class. * If type_spec_class == REGISTERED_TYPE_SPEC, the TypeSpec class is the one registered under this name. For types registered outside core TensorFlow by an add-on library, that library must be loaded before this value can be deserialized by nested_structure_coder. * If type_spec_class specifies a particular TypeSpec class, this field is redundant with the type_spec_class enum, and is only used for error reporting in older binaries that do not know the tupe_spec_class enum.
int32 num_flat_components = 4
The number of flat tensor components required by this TypeSpec.
Used in:
UNKNOWN = 0
SPARSE_TENSOR_SPEC = 1
tf.SparseTensorSpec
INDEXED_SLICES_SPEC = 2
tf.IndexedSlicesSpec
RAGGED_TENSOR_SPEC = 3
tf.RaggedTensorSpec
TENSOR_ARRAY_SPEC = 4
tf.TensorArraySpec
DATA_DATASET_SPEC = 5
tf.data.DatasetSpec
DATA_ITERATOR_SPEC = 6
IteratorSpec from data/ops/iterator_ops.py
OPTIONAL_SPEC = 7
tf.OptionalSpec
PER_REPLICA_SPEC = 8
PerReplicaSpec from distribute/values.py
VARIABLE_SPEC = 9
tf.VariableSpec
ROW_PARTITION_SPEC = 10
RowPartitionSpec from ragged/row_partition.py
REGISTERED_TYPE_SPEC = 12
The type registered as type_spec_class_name.
EXTENSION_TYPE_SPEC = 13
Subclasses of tf.ExtensionType
message
uniform_quant_ops_attr.proto:24Describes the dimension numbers for Convolution op. Corresponds to ::mlir::mhlo::ConvDimensionNumbersAttr.
int64 input_batch_dimension = 1
The dimension that represents batch in the input.
int64 input_feature_dimension = 2
The dimension that represents features in the input.
repeated int64 input_spatial_dimensions = 3
The dimensions that represents spatial dimensions in the input. Length must be rank-2 for the tensor rank for Convolution op.
int64 kernel_input_feature_dimension = 4
The dimension that represents input features in the kernel (rhs).
int64 kernel_output_feature_dimension = 5
The dimension that represents output features in the kernel (rhs).
repeated int64 kernel_spatial_dimensions = 6
The dimensions that represents spatial dimensions in the kernel (rhs). Length must be rank-2 for the tensor rank for Convolution op.
int64 output_batch_dimension = 7
The dimension that represents batch in the output.
int64 output_feature_dimension = 8
The dimension that represents features in the output.
repeated int64 output_spatial_dimensions = 9
The dimensions that represents spatial dimensions in the output. Length must be rank-2 for the tensor rank for Convolution op.
message
control_flow.proto:14Protocol buffer representing the values in ControlFlowContext.
Used in: ,
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:
DataType dtype = 1
string values_output_tensor_name = 2
string indices_output_tensor_name = 3
string shapes_output_tensor_name = 4
Indicates how a distributed variable will be aggregated.
Used in: ,
VARIABLE_AGGREGATION_NONE = 0
`NONE`: This is the default, giving an error if you use a variable-update operation with multiple replicas.
VARIABLE_AGGREGATION_SUM = 1
`SUM`: Add the updates across replicas.
VARIABLE_AGGREGATION_MEAN = 2
`MEAN`: Take the arithmetic mean ("average") of the updates across replicas.
VARIABLE_AGGREGATION_ONLY_FIRST_REPLICA = 3
`ONLY_FIRST_REPLICA`: This is for when every replica is performing the same update, but we only want to perform the update once. Used, e.g., for the global step counter.
message
variable.proto:46Protocol 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 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.
bool trainable = 7
Whether this variable should be trained.
VariableSynchronization synchronization = 8
Indicates when a distributed variable will be synced.
VariableAggregation aggregation = 9
Indicates how a distributed variable will be aggregated.
Indicates when a distributed variable will be synced.
Used in: ,
VARIABLE_SYNCHRONIZATION_AUTO = 0
`AUTO`: Indicates that the synchronization will be determined by the current `DistributionStrategy` (eg. With `MirroredStrategy` this would be `ON_WRITE`).
VARIABLE_SYNCHRONIZATION_NONE = 1
`NONE`: Indicates that there will only be one copy of the variable, so there is no need to sync.
VARIABLE_SYNCHRONIZATION_ON_WRITE = 2
`ON_WRITE`: Indicates that the variable will be updated across devices every time it is written.
VARIABLE_SYNCHRONIZATION_ON_READ = 3
`ON_READ`: Indicates that the variable will be aggregated across devices when it is read (eg. when checkpointing or when evaluating an op that uses the variable).
message
tensor.proto:89Protocol buffer representing the serialization format of DT_VARIANT tensors.
Used in:
string type_name = 1
Name of the type of objects being serialized.
bytes metadata = 2
Portions of the object that are not Tensors.
repeated tensors = 3
Tensors contained within objects being serialized.
message
verifier_config.proto:12The config for graph verifiers.
Used in:
int64 verification_timeout_in_ms = 1
Deadline for completion of all verification i.e. all the Toggle ON verifiers must complete execution within this time.
VerifierConfig.Toggle structure_verifier = 2
Perform structural validation on a tensorflow graph. Default is OFF.
Used in:
DEFAULT = 0
ON = 1
OFF = 2
message
versions.proto:24Version 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: , , , , ,
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).
message
event.proto:112Used in:
int64 timeout_ms = 1
message
control_flow.proto:53Protocol buffer representing a WhileContext object.
Used in:
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 values_def = 9
Values and external values in control flow context.
string maximum_iterations_name = 11
Optional name of the maximum_iterations tensor.
repeated nested_contexts = 12
Contexts contained inside this context (e.g. nested whiles).
Current health status of a worker.
Used in:
OK = 0
By default a worker is healthy.
RECEIVED_SHUTDOWN_SIGNAL = 1
INTERNAL_ERROR = 2
SHUTTING_DOWN = 3
Worker has been instructed to shutdown after a timeout.
message
event.proto:120WorkerShutdownMode shutdown_mode = 1
optional watchdog_config = 2
optional exit_code = 3
message
event.proto:126WorkerHealth health_status = 1
repeated worker_log = 2
string hostname = 3
Indicates the behavior of the worker when an internal error or shutdown signal is received.
Used in:
DEFAULT = 0
NOT_CONFIGURED = 1
WAIT_FOR_COORDINATOR = 2
SHUTDOWN_AFTER_TIMEOUT = 3
message
xla_activity.proto:67Listeners listening for auto clustering events get messages of this type. Next ID: 4
OptimizerOptions.GlobalJitLevel global_jit_level = 1
The value of GlobalJitLevel, as determined by `GetGlobalJitLevelForGraph`. This determines if global auto-clustering is enabled.
bool cpu_global_jit_enabled = 2
Whether --tf_xla_cpu_global_jit is enabled in TF_XLA_FLAGS.
optional summary = 3
message
xla_activity.proto:25Summarizes the results of auto-clustering a TensorFlow graph. Next ID: 5
Used in:
int32 unclustered_node_count = 1
The number of nodes in the graph that are not inside an XLA cluster.
int32 clustered_node_count = 2
The number of nodes in the graph that are in an XLA cluster.
repeated clusters = 3
All of the XLA clusters in the TF graph.
repeated unclustered_op_histogram = 4
A histogram of the TF operations that were not clustered.
message
xla_activity.proto:41Describes a single XLA cluster. Next ID: 4
Used in:
string name = 1
int32 size = 2
The number of nodes in the cluster.
repeated op_histogram = 3
A histogram of the TF operations in this cluster.
message
xla_activity.proto:30Represents a single element in a histogram of ops ("op" as in "TensorFlow operation"). Next ID: 3
Used in: ,
string op = 1
The TensorFlow operation (like MatMult, Add etc.)
int32 count = 2
The number of times this occurs.
message
coordination_service.proto:55Used in:
optional devices = 1
message
xla_activity.proto:85Listeners listening for JIT compilation events get messages of this type. Each instance of XlaJitCompilationActivity corresponds to a single compilation of a single XLA cluster. E.g. if a graph has two clusters, A and B, and A is compiled 5 times and B is compiled 2 times then we will generate 7 instances of XlaJitCompilationActivity. Next ID: 6
string cluster_name = 1
int32 compile_count = 2
The number of time this cluster has been compiled.
int64 compile_time_us = 3
Microseconds spent in the individual compilation being reported.
int64 cumulative_compile_time_us = 4
Total microseconds spent in (re-)compiling this cluster so far.
bool used_persistent_cache = 5
Whether a persistent compilation cache entry was used.
message
xla_activity.proto:107LINT.IfChange Used for logging situations seen in Tensorflow models being optimized that are known to not perform well with XLA. Next ID: 3
XlaOptimizationRemark.Warning warning = 1
string debug_information = 2
Information such as which node was the problem.
Next ID: 6
Used in:
NONE = 0
INACCURATE_OPERATION = 1
SLOW_OPERATION = 2
UNIMPLEMENTED_OPERATION = 3
SLOW_IMAGE_RESIZE_DIMENSIONS = 4
MEGAMORPHIC_FUNCTION = 5
message
xla_compilation_cache.proto:31Represents an entry in the XLA compile cache.
optional key = 1
Used to uniqely identify this entry in its persisted representation.
optional hlo_module = 2
The computation (HLO) that compilation was done for. It is correlated to the input TF graph so we can use it to fingerprint the compiled binary. We serialize this rather than the input graphdef because it provides a stronger guarantee over what bindings are needed between the HLO and calling TF graph.
bytes executable = 3
The raw bytes of the executable.
message
xla_compilation_cache.proto:23Represents the cache key used for persistence.
Used in:
uint64 signature_fingerprint = 1
uint64 cluster_fingerprint = 2
string device_type = 3
string prefix = 4