protobuf

type AssetFileDef struct {
	// The tensor to bind the asset filename to.
	TensorInfo *TensorInfo `protobuf:"bytes,1,opt,name=tensor_info,json=tensorInfo" json:"tensor_info,omitempty"`
	// 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".
	Filename string `protobuf:"bytes,2,opt,name=filename" json:"filename,omitempty"`
}

type AutoParallelOptions struct {
	Enable      bool  `protobuf:"varint,1,opt,name=enable" json:"enable,omitempty"`
	NumReplicas int32 `protobuf:"varint,2,opt,name=num_replicas,json=numReplicas" json:"num_replicas,omitempty"`
}

type BundleEntryProto struct {
	// The tensor dtype and shape.
	Dtype tensorflow1.DataType         `protobuf:"varint,1,opt,name=dtype,enum=tensorflow.DataType" json:"dtype,omitempty"`
	Shape *tensorflow.TensorShapeProto `protobuf:"bytes,2,opt,name=shape" json:"shape,omitempty"`
	// The binary content of the tensor lies in:
	//   File "shard_id": bytes [offset, offset + size).
	ShardId int32 `protobuf:"varint,3,opt,name=shard_id,json=shardId" json:"shard_id,omitempty"`
	Offset  int64 `protobuf:"varint,4,opt,name=offset" json:"offset,omitempty"`
	Size    int64 `protobuf:"varint,5,opt,name=size" json:"size,omitempty"`
	// The CRC32C checksum of the tensor bytes.
	Crc32C uint32 `protobuf:"fixed32,6,opt,name=crc32c" json:"crc32c,omitempty"`
	// 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".
	Slices []*tensorflow15.TensorSliceProto `protobuf:"bytes,7,rep,name=slices" json:"slices,omitempty"`
}

type BundleHeaderProto struct {
	// Number of data files in the bundle.
	NumShards  int32                        `protobuf:"varint,1,opt,name=num_shards,json=numShards" json:"num_shards,omitempty"`
	Endianness BundleHeaderProto_Endianness `protobuf:"varint,2,opt,name=endianness,enum=tensorflow.BundleHeaderProto_Endianness" json:"endianness,omitempty"`
	// Versioning of the tensor bundle format.
	Version *tensorflow9.VersionDef `protobuf:"bytes,3,opt,name=version" json:"version,omitempty"`
}

type BundleHeaderProto_Endianness int32

type CleanupAllRequest struct {
	// A list of container names.
	//
	// If 'container' is not empty, releases resoures in the given
	// containers in all devices.
	//
	// If 'container' is empty, releases resources in the default
	// container in all devices.
	Container []string `protobuf:"bytes,1,rep,name=container" json:"container,omitempty"`
}

type CleanupAllResponse struct {
}

type CleanupGraphRequest struct {
	StepId int64 `protobuf:"varint,1,opt,name=step_id,json=stepId" json:"step_id,omitempty"`
}

type CleanupGraphResponse struct {
}

type CloseSessionRequest struct {
	// REQUIRED: session_handle must be returned by a CreateSession call
	// to the same master service.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
}

type CloseSessionResponse struct {
}

type ClusterDef struct {
	// The jobs that comprise the cluster.
	Job []*JobDef `protobuf:"bytes,1,rep,name=job" json:"job,omitempty"`
}

type CollectionDef struct {
	// Types that are valid to be assigned to Kind:
	//	*CollectionDef_NodeList_
	//	*CollectionDef_BytesList_
	//	*CollectionDef_Int64List_
	//	*CollectionDef_FloatList_
	//	*CollectionDef_AnyList_
	Kind isCollectionDef_Kind `protobuf_oneof:"kind"`
}

type CollectionDef_AnyList struct {
	Value []*google_protobuf.Any `protobuf:"bytes,1,rep,name=value" json:"value,omitempty"`
}

type CollectionDef_AnyList_ struct {
	AnyList *CollectionDef_AnyList `protobuf:"bytes,5,opt,name=any_list,json=anyList,oneof"`
}

type CollectionDef_BytesList struct {
	Value [][]byte `protobuf:"bytes,1,rep,name=value,proto3" json:"value,omitempty"`
}

type CollectionDef_BytesList_ struct {
	BytesList *CollectionDef_BytesList `protobuf:"bytes,2,opt,name=bytes_list,json=bytesList,oneof"`
}

type CollectionDef_FloatList struct {
	Value []float32 `protobuf:"fixed32,1,rep,packed,name=value" json:"value,omitempty"`
}

type CollectionDef_FloatList_ struct {
	FloatList *CollectionDef_FloatList `protobuf:"bytes,4,opt,name=float_list,json=floatList,oneof"`
}

type CollectionDef_Int64List struct {
	Value []int64 `protobuf:"varint,1,rep,packed,name=value" json:"value,omitempty"`
}

type CollectionDef_Int64List_ struct {
	Int64List *CollectionDef_Int64List `protobuf:"bytes,3,opt,name=int64_list,json=int64List,oneof"`
}

type CollectionDef_NodeList struct {
	Value []string `protobuf:"bytes,1,rep,name=value" json:"value,omitempty"`
}

type CollectionDef_NodeList_ struct {
	NodeList *CollectionDef_NodeList `protobuf:"bytes,1,opt,name=node_list,json=nodeList,oneof"`
}

type CondContextDef struct {
	// Name of the context.
	ContextName string `protobuf:"bytes,1,opt,name=context_name,json=contextName" json:"context_name,omitempty"`
	// Name of the pred tensor.
	PredName string `protobuf:"bytes,2,opt,name=pred_name,json=predName" json:"pred_name,omitempty"`
	// Name of the pivot tensor.
	PivotName string `protobuf:"bytes,3,opt,name=pivot_name,json=pivotName" json:"pivot_name,omitempty"`
	// Branch prediction. 0 or 1.
	Branch int32 `protobuf:"varint,4,opt,name=branch" json:"branch,omitempty"`
	// Values and external values in control flow context.
	ValuesDef *ValuesDef `protobuf:"bytes,5,opt,name=values_def,json=valuesDef" json:"values_def,omitempty"`
}

type ConfigProto struct {
	// 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.
	DeviceCount map[string]int32 `` /* 162-byte string literal not displayed */
	// 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.
	IntraOpParallelismThreads int32 `` /* 134-byte string literal not displayed */
	// Nodes that perform blocking operations are enqueued on a pool of
	// inter_op_parallelism_threads available in each process.
	//
	// 0 means the system picks an appropriate number.
	//
	// Note that the first Session created in the process sets the
	// number of threads for all future sessions unless use_per_session_threads is
	// true or session_inter_op_thread_pool is configured.
	InterOpParallelismThreads int32 `` /* 134-byte string literal not displayed */
	// 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.
	UsePerSessionThreads bool `protobuf:"varint,9,opt,name=use_per_session_threads,json=usePerSessionThreads" json:"use_per_session_threads,omitempty"`
	// This option is experimental - it may be replaced with a different mechanism
	// in the future. The intended use is for when some session invocations need
	// to run in a background pool limited to a small number of threads.
	//
	// Configures session thread pools. If this is configured, then RunOptions for
	// a Run call can select the thread pool to use.
	//
	// If a pool's num_threads is 0, then inter_op_parallelism_threads is used.
	SessionInterOpThreadPool []*ThreadPoolOptionProto `` /* 133-byte string literal not displayed */
	// 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).
	PlacementPeriod int32 `protobuf:"varint,3,opt,name=placement_period,json=placementPeriod" json:"placement_period,omitempty"`
	// 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.
	DeviceFilters []string `protobuf:"bytes,4,rep,name=device_filters,json=deviceFilters" json:"device_filters,omitempty"`
	// Options that apply to all GPUs.
	GpuOptions *GPUOptions `protobuf:"bytes,6,opt,name=gpu_options,json=gpuOptions" json:"gpu_options,omitempty"`
	// 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.
	AllowSoftPlacement bool `protobuf:"varint,7,opt,name=allow_soft_placement,json=allowSoftPlacement" json:"allow_soft_placement,omitempty"`
	// Whether device placements should be logged.
	LogDevicePlacement bool `protobuf:"varint,8,opt,name=log_device_placement,json=logDevicePlacement" json:"log_device_placement,omitempty"`
	// Options that apply to all graphs.
	GraphOptions *GraphOptions `protobuf:"bytes,10,opt,name=graph_options,json=graphOptions" json:"graph_options,omitempty"`
	// 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.
	OperationTimeoutInMs int64 `protobuf:"varint,11,opt,name=operation_timeout_in_ms,json=operationTimeoutInMs" json:"operation_timeout_in_ms,omitempty"`
	// Options that apply when this session uses the distributed runtime.
	RpcOptions *RPCOptions `protobuf:"bytes,13,opt,name=rpc_options,json=rpcOptions" json:"rpc_options,omitempty"`
	// Optional list of all workers to use in this session.
	ClusterDef *ClusterDef `protobuf:"bytes,14,opt,name=cluster_def,json=clusterDef" json:"cluster_def,omitempty"`
}

type CreateSessionRequest struct {
	// The initial graph definition.
	GraphDef *tensorflow10.GraphDef `protobuf:"bytes,1,opt,name=graph_def,json=graphDef" json:"graph_def,omitempty"`
	// Configuration options.
	Config *ConfigProto `protobuf:"bytes,2,opt,name=config" json:"config,omitempty"`
	// The target string used from the client's perspective.
	Target string `protobuf:"bytes,3,opt,name=target" json:"target,omitempty"`
}

type CreateSessionResponse struct {
	// 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.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
	// The initial version number for the graph, to be used in the next call
	// to ExtendSession.
	GraphVersion int64 `protobuf:"varint,2,opt,name=graph_version,json=graphVersion" json:"graph_version,omitempty"`
}

type CreateWorkerSessionRequest struct {
	// Sessions are identified by a given handle.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
	// Defines the configuration of a TensorFlow worker.
	ServerDef *ServerDef `protobuf:"bytes,2,opt,name=server_def,json=serverDef" json:"server_def,omitempty"`
}

type CreateWorkerSessionResponse struct {
}

type DebugOptions struct {
	// Debugging options
	DebugTensorWatchOpts []*DebugTensorWatch `protobuf:"bytes,4,rep,name=debug_tensor_watch_opts,json=debugTensorWatchOpts" json:"debug_tensor_watch_opts,omitempty"`
	// Caller-specified global step count.
	// Note that this is distinct from the session run count and the executor
	// step count.
	GlobalStep int64 `protobuf:"varint,10,opt,name=global_step,json=globalStep" json:"global_step,omitempty"`
}

type DebugTensorWatch struct {
	// Name of the node to watch.
	NodeName string `protobuf:"bytes,1,opt,name=node_name,json=nodeName" json:"node_name,omitempty"`
	// Output slot to watch.
	// The semantics of output_slot == -1 is that the node is only watched for
	// completion, but not for any output tensors. See NodeCompletionCallback
	// in debug_gateway.h.
	// TODO(cais): Implement this semantics.
	OutputSlot int32 `protobuf:"varint,2,opt,name=output_slot,json=outputSlot" json:"output_slot,omitempty"`
	// Name(s) of the debugging op(s).
	// One or more than one probes on a tensor.
	// e.g., {"DebugIdentity", "DebugNanCount"}
	DebugOps []string `protobuf:"bytes,3,rep,name=debug_ops,json=debugOps" json:"debug_ops,omitempty"`
	// URL(s) for debug targets(s).
	//   E.g., "file:///foo/tfdbg_dump", "grpc://localhost:11011"
	// 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.
	DebugUrls []string `protobuf:"bytes,4,rep,name=debug_urls,json=debugUrls" json:"debug_urls,omitempty"`
	// Do not error out if debug op creation fails (e.g., due to dtype
	// incompatibility). Instead, just log the failure.
	TolerateDebugOpCreationFailures bool `` /* 154-byte string literal not displayed */
}

type DeregisterGraphRequest struct {
	// The session_handle used when registering the graph. If session_handle is
	// empty, a single global namespace is used.
	SessionHandle string `protobuf:"bytes,2,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
	// REQUIRED: graph_handle must be returned by a RegisterGraph call
	// to the same WorkerService.
	GraphHandle string `protobuf:"bytes,1,opt,name=graph_handle,json=graphHandle" json:"graph_handle,omitempty"`
}

type DeregisterGraphResponse struct {
}

type DeviceMap struct {
	NameAndDevice []*DeviceMap_NamedDevice `protobuf:"bytes,1,rep,name=name_and_device,json=nameAndDevice" json:"name_and_device,omitempty"`
}

type DeviceMap_NamedDevice struct {
	Name   string            `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Device *DeviceProperties `protobuf:"bytes,2,opt,name=device" json:"device,omitempty"`
}

type DeviceProperties struct {
	// Device type (CPU, GPU, ...)
	Type string `protobuf:"bytes,1,opt,name=type" json:"type,omitempty"`
	// Vendor (Intel, nvidia, ...)
	Vendor string `protobuf:"bytes,2,opt,name=vendor" json:"vendor,omitempty"`
	// Model (Haswell, K40, ...)
	Model string `protobuf:"bytes,3,opt,name=model" json:"model,omitempty"`
	// Core Frequency in Mhz
	Frequency int64 `protobuf:"varint,4,opt,name=frequency" json:"frequency,omitempty"`
	// Number of cores
	NumCores int64 `protobuf:"varint,5,opt,name=num_cores,json=numCores" json:"num_cores,omitempty"`
	// Version of the tools and libraries used with this device (e.g. gcc 4.9,
	// cudnn 5.1)
	Environment map[string]string `` /* 142-byte string literal not displayed */
	// Number of registers per core.
	NumRegisters int64 `protobuf:"varint,7,opt,name=num_registers,json=numRegisters" json:"num_registers,omitempty"`
	// L1 cache size in bytes
	L1CacheSize int64 `protobuf:"varint,8,opt,name=l1_cache_size,json=l1CacheSize" json:"l1_cache_size,omitempty"`
	// L2 cache size in bytes
	L2CacheSize int64 `protobuf:"varint,9,opt,name=l2_cache_size,json=l2CacheSize" json:"l2_cache_size,omitempty"`
	// L3 cache size in bytes
	L3CacheSize int64 `protobuf:"varint,10,opt,name=l3_cache_size,json=l3CacheSize" json:"l3_cache_size,omitempty"`
	// Shared memory size per multiprocessor in bytes. This field is
	// applicable to GPUs only.
	SharedMemorySizePerMultiprocessor int64 `` /* 161-byte string literal not displayed */
	// Memory size in bytes
	MemorySize int64 `protobuf:"varint,12,opt,name=memory_size,json=memorySize" json:"memory_size,omitempty"`
	// Memory bandwidth in KB/s
	Bandwidth int64 `protobuf:"varint,13,opt,name=bandwidth" json:"bandwidth,omitempty"`
}

type ExecutorOpts struct {
	RecordCosts    bool `protobuf:"varint,1,opt,name=record_costs,json=recordCosts" json:"record_costs,omitempty"`
	RecordTimeline bool `protobuf:"varint,3,opt,name=record_timeline,json=recordTimeline" json:"record_timeline,omitempty"`
}

type ExtendSessionRequest struct {
	// REQUIRED: session_handle must be returned by a CreateSession call
	// to the same master service.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
	// 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.
	GraphDef *tensorflow10.GraphDef `protobuf:"bytes,2,opt,name=graph_def,json=graphDef" json:"graph_def,omitempty"`
	// 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.
	CurrentGraphVersion int64 `protobuf:"varint,3,opt,name=current_graph_version,json=currentGraphVersion" json:"current_graph_version,omitempty"`
}

type ExtendSessionResponse struct {
	// The new version number for the extended graph, to be used in the next call
	// to ExtendSession.
	NewGraphVersion int64 `protobuf:"varint,4,opt,name=new_graph_version,json=newGraphVersion" json:"new_graph_version,omitempty"`
}

type GPUOptions struct {
	// A value between 0 and 1 that indicates what fraction of the
	// available GPU memory to pre-allocate for each process.  1 means
	// to pre-allocate all of the GPU memory, 0.5 means the process
	// allocates ~50% of the available GPU memory.
	PerProcessGpuMemoryFraction float64 `` /* 143-byte string literal not displayed */
	// 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.
	AllocatorType string `protobuf:"bytes,2,opt,name=allocator_type,json=allocatorType" json:"allocator_type,omitempty"`
	// 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).
	DeferredDeletionBytes int64 `protobuf:"varint,3,opt,name=deferred_deletion_bytes,json=deferredDeletionBytes" json:"deferred_deletion_bytes,omitempty"`
	// If true, the allocator does not pre-allocate the entire specified
	// GPU memory region, instead starting small and growing as needed.
	AllowGrowth bool `protobuf:"varint,4,opt,name=allow_growth,json=allowGrowth" json:"allow_growth,omitempty"`
	// 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 "/gpu:0", and "/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: 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.
	VisibleDeviceList string `protobuf:"bytes,5,opt,name=visible_device_list,json=visibleDeviceList" json:"visible_device_list,omitempty"`
	// 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.
	PollingActiveDelayUsecs int32 `` /* 128-byte string literal not displayed */
	// In the event polling loop sleep this many millisconds between
	// PollEvents calls, when the queue is empty.  If value is not
	// set or set to 0, gets set to a non-zero default.
	PollingInactiveDelayMsecs int32 `` /* 134-byte string literal not displayed */
	// 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.
	ForceGpuCompatible bool `protobuf:"varint,8,opt,name=force_gpu_compatible,json=forceGpuCompatible" json:"force_gpu_compatible,omitempty"`
}

type GetStatusRequest struct {
}

type GetStatusResponse struct {
	DeviceAttributes []*tensorflow14.DeviceAttributes `protobuf:"bytes,1,rep,name=device_attributes,json=deviceAttributes" json:"device_attributes,omitempty"`
}

type GraphOptions struct {
	// If true, use control flow to schedule the activation of Recv nodes.
	// (Currently ignored.)
	EnableRecvScheduling bool `protobuf:"varint,2,opt,name=enable_recv_scheduling,json=enableRecvScheduling" json:"enable_recv_scheduling,omitempty"`
	// Options controlling how graph is optimized.
	OptimizerOptions *OptimizerOptions `protobuf:"bytes,3,opt,name=optimizer_options,json=optimizerOptions" json:"optimizer_options,omitempty"`
	// 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.
	BuildCostModel int64 `protobuf:"varint,4,opt,name=build_cost_model,json=buildCostModel" json:"build_cost_model,omitempty"`
	// The number of steps to skip before collecting statistics for the
	// cost model.
	BuildCostModelAfter int64 `protobuf:"varint,9,opt,name=build_cost_model_after,json=buildCostModelAfter" json:"build_cost_model_after,omitempty"`
	// Annotate each Node with Op output shape data, to the extent it can
	// be statically inferred.
	InferShapes bool `protobuf:"varint,5,opt,name=infer_shapes,json=inferShapes" json:"infer_shapes,omitempty"`
	// 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.
	PlacePrunedGraph bool `protobuf:"varint,6,opt,name=place_pruned_graph,json=placePrunedGraph" json:"place_pruned_graph,omitempty"`
	// If true, transfer float values between processes as bfloat16.
	EnableBfloat16Sendrecv bool `protobuf:"varint,7,opt,name=enable_bfloat16_sendrecv,json=enableBfloat16Sendrecv" json:"enable_bfloat16_sendrecv,omitempty"`
	// If > 0, record a timeline every this many steps.
	// EXPERIMENTAL: This currently has no effect in MasterSession.
	TimelineStep int32 `protobuf:"varint,8,opt,name=timeline_step,json=timelineStep" json:"timeline_step,omitempty"`
	// 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).
	RewriteOptions *RewriterConfig `protobuf:"bytes,10,opt,name=rewrite_options,json=rewriteOptions" json:"rewrite_options,omitempty"`
}

type JobDef struct {
	// The name of this job.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// 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".
	Tasks map[int32]string `` /* 131-byte string literal not displayed */
}

type LabeledStepStats struct {
	StepId    int64                   `protobuf:"varint,1,opt,name=step_id,json=stepId" json:"step_id,omitempty"`
	StepStats *tensorflow13.StepStats `protobuf:"bytes,2,opt,name=step_stats,json=stepStats" json:"step_stats,omitempty"`
}

type ListDevicesRequest struct {
	// 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.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
}

type ListDevicesResponse struct {
	LocalDevice  []*tensorflow14.DeviceAttributes `protobuf:"bytes,1,rep,name=local_device,json=localDevice" json:"local_device,omitempty"`
	RemoteDevice []*tensorflow14.DeviceAttributes `protobuf:"bytes,2,rep,name=remote_device,json=remoteDevice" json:"remote_device,omitempty"`
}

type LoggingRequest struct {
	// If true, RPC logging will be activated.
	RpcLogging bool `protobuf:"varint,1,opt,name=rpc_logging,json=rpcLogging" json:"rpc_logging,omitempty"`
	// If true, discard any saved logging data (for all steps).
	Clear bool `protobuf:"varint,2,opt,name=clear" json:"clear,omitempty"`
	// 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.
	FetchStepId []int64 `protobuf:"varint,3,rep,packed,name=fetch_step_id,json=fetchStepId" json:"fetch_step_id,omitempty"`
}

type LoggingResponse struct {
	Step []*LabeledStepStats `protobuf:"bytes,1,rep,name=step" json:"step,omitempty"`
}

type MasterServiceClient interface {
	// Creates a session.
	CreateSession(ctx context.Context, in *CreateSessionRequest, opts ...grpc.CallOption) (*CreateSessionResponse, error)
	// Extends a session.
	ExtendSession(ctx context.Context, in *ExtendSessionRequest, opts ...grpc.CallOption) (*ExtendSessionResponse, error)
	// Prepares future partial run calls.
	PartialRunSetup(ctx context.Context, in *PartialRunSetupRequest, opts ...grpc.CallOption) (*PartialRunSetupResponse, error)
	// Drives the graph computation.
	RunStep(ctx context.Context, in *RunStepRequest, opts ...grpc.CallOption) (*RunStepResponse, error)
	// Closes a session.
	CloseSession(ctx context.Context, in *CloseSessionRequest, opts ...grpc.CallOption) (*CloseSessionResponse, error)
	// List the devices usable by the master.
	ListDevices(ctx context.Context, in *ListDevicesRequest, opts ...grpc.CallOption) (*ListDevicesResponse, error)
	// Close and abandon all existing sessions.  Ongoing computations
	// will no longer affect fresh ones via the resources in containers listed in
	// the ResetRequest.  See ResetRequest for more details.
	Reset(ctx context.Context, in *ResetRequest, opts ...grpc.CallOption) (*ResetResponse, error)
}

type MasterServiceServer interface {
	// Creates a session.
	CreateSession(context.Context, *CreateSessionRequest) (*CreateSessionResponse, error)
	// Extends a session.
	ExtendSession(context.Context, *ExtendSessionRequest) (*ExtendSessionResponse, error)
	// Prepares future partial run calls.
	PartialRunSetup(context.Context, *PartialRunSetupRequest) (*PartialRunSetupResponse, error)
	// Drives the graph computation.
	RunStep(context.Context, *RunStepRequest) (*RunStepResponse, error)
	// Closes a session.
	CloseSession(context.Context, *CloseSessionRequest) (*CloseSessionResponse, error)
	// List the devices usable by the master.
	ListDevices(context.Context, *ListDevicesRequest) (*ListDevicesResponse, error)
	// Close and abandon all existing sessions.  Ongoing computations
	// will no longer affect fresh ones via the resources in containers listed in
	// the ResetRequest.  See ResetRequest for more details.
	Reset(context.Context, *ResetRequest) (*ResetResponse, error)
}

type MetaGraphDef struct {
	MetaInfoDef *MetaGraphDef_MetaInfoDef `protobuf:"bytes,1,opt,name=meta_info_def,json=metaInfoDef" json:"meta_info_def,omitempty"`
	// GraphDef.
	GraphDef *tensorflow10.GraphDef `protobuf:"bytes,2,opt,name=graph_def,json=graphDef" json:"graph_def,omitempty"`
	// SaverDef.
	SaverDef *SaverDef `protobuf:"bytes,3,opt,name=saver_def,json=saverDef" json:"saver_def,omitempty"`
	// collection_def: Map from collection name to collections.
	// See CollectionDef section for details.
	CollectionDef map[string]*CollectionDef `` /* 167-byte string literal not displayed */
	// signature_def: Map from user supplied key for a signature to a single
	// SignatureDef.
	SignatureDef map[string]*SignatureDef `` /* 164-byte string literal not displayed */
	// Asset file def to be used with the defined graph.
	AssetFileDef []*AssetFileDef `protobuf:"bytes,6,rep,name=asset_file_def,json=assetFileDef" json:"asset_file_def,omitempty"`
}

type MetaGraphDef_MetaInfoDef struct {
	// User specified Version string. Can be the name of the model and revision,
	// steps this model has been trained to, etc.
	MetaGraphVersion string `protobuf:"bytes,1,opt,name=meta_graph_version,json=metaGraphVersion" json:"meta_graph_version,omitempty"`
	// A copy of the OpDefs used by the producer of this graph_def.
	// Descriptions and Ops not used in graph_def are stripped out.
	StrippedOpList *tensorflow7.OpList `protobuf:"bytes,2,opt,name=stripped_op_list,json=strippedOpList" json:"stripped_op_list,omitempty"`
	// A serialized protobuf. Can be the time this meta graph is created, or
	// modified, or name of the model.
	AnyInfo *google_protobuf.Any `protobuf:"bytes,3,opt,name=any_info,json=anyInfo" json:"any_info,omitempty"`
	// 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.
	Tags []string `protobuf:"bytes,4,rep,name=tags" json:"tags,omitempty"`
	// 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.
	TensorflowVersion string `protobuf:"bytes,5,opt,name=tensorflow_version,json=tensorflowVersion" json:"tensorflow_version,omitempty"`
	// 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.
	TensorflowGitVersion string `protobuf:"bytes,6,opt,name=tensorflow_git_version,json=tensorflowGitVersion" json:"tensorflow_git_version,omitempty"`
}

type NamedTensorProto struct {
	// Name of the tensor.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// 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.
	Tensor *tensorflow4.TensorProto `protobuf:"bytes,2,opt,name=tensor" json:"tensor,omitempty"`
}

type OptimizerOptions struct {
	// If true, optimize the graph using common subexpression elimination.
	DoCommonSubexpressionElimination bool `` /* 155-byte string literal not displayed */
	// If true, perform constant folding optimization on the graph.
	DoConstantFolding bool `protobuf:"varint,2,opt,name=do_constant_folding,json=doConstantFolding" json:"do_constant_folding,omitempty"`
	// If true, perform function inlining on the graph.
	DoFunctionInlining bool                            `protobuf:"varint,4,opt,name=do_function_inlining,json=doFunctionInlining" json:"do_function_inlining,omitempty"`
	OptLevel           OptimizerOptions_Level          `protobuf:"varint,3,opt,name=opt_level,json=optLevel,enum=tensorflow.OptimizerOptions_Level" json:"opt_level,omitempty"`
	GlobalJitLevel     OptimizerOptions_GlobalJitLevel `` /* 147-byte string literal not displayed */
}

type OptimizerOptions_GlobalJitLevel int32

type OptimizerOptions_Level int32

type PartialRunSetupRequest struct {
	// REQUIRED: session_handle must be returned by a CreateSession call
	// to the same master service.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
	// Tensors to be fed in future steps.
	Feed []string `protobuf:"bytes,2,rep,name=feed" json:"feed,omitempty"`
	// 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.
	Fetch []string `protobuf:"bytes,3,rep,name=fetch" json:"fetch,omitempty"`
	// Target Nodes. A list of node names. The named nodes will be run in future
	// steps, but their outputs will not be fetched.
	Target []string `protobuf:"bytes,4,rep,name=target" json:"target,omitempty"`
}

type PartialRunSetupResponse struct {
	// 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.
	PartialRunHandle string `protobuf:"bytes,1,opt,name=partial_run_handle,json=partialRunHandle" json:"partial_run_handle,omitempty"`
}

type QueueRunnerDef struct {
	// Queue name.
	QueueName string `protobuf:"bytes,1,opt,name=queue_name,json=queueName" json:"queue_name,omitempty"`
	// A list of enqueue operations.
	EnqueueOpName []string `protobuf:"bytes,2,rep,name=enqueue_op_name,json=enqueueOpName" json:"enqueue_op_name,omitempty"`
	// The operation to run to close the queue.
	CloseOpName string `protobuf:"bytes,3,opt,name=close_op_name,json=closeOpName" json:"close_op_name,omitempty"`
	// The operation to run to cancel the queue.
	CancelOpName string `protobuf:"bytes,4,opt,name=cancel_op_name,json=cancelOpName" json:"cancel_op_name,omitempty"`
	// A list of exception types considered to signal a safely closed queue
	// if raised during enqueue operations.
	QueueClosedExceptionTypes []tensorflow_error.Code `` /* 168-byte string literal not displayed */
}

type RPCOptions struct {
	// 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.
	UseRpcForInprocessMaster bool `` /* 133-byte string literal not displayed */
}

type RecvTensorRequest struct {
	// 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.
	StepId int64 `protobuf:"varint,1,opt,name=step_id,json=stepId" json:"step_id,omitempty"`
	// A key that identifies the tensor to be received.
	RendezvousKey string `protobuf:"bytes,2,opt,name=rendezvous_key,json=rendezvousKey" json:"rendezvous_key,omitempty"`
	// If true, use an out-of-band DMA mechanism to transfer the
	// received tensor.
	DmaOk bool `protobuf:"varint,3,opt,name=dma_ok,json=dmaOk" json:"dma_ok,omitempty"`
	// Optional information on client-side device locality.
	ClientLocality *tensorflow14.DeviceLocality `protobuf:"bytes,4,opt,name=client_locality,json=clientLocality" json:"client_locality,omitempty"`
	// Optional information on server-side device locality.
	ServerLocality *tensorflow14.DeviceLocality `protobuf:"bytes,5,opt,name=server_locality,json=serverLocality" json:"server_locality,omitempty"`
	// Optional information needed by the RPC subsystem.
	TransportOptions *google_protobuf.Any `protobuf:"bytes,6,opt,name=transport_options,json=transportOptions" json:"transport_options,omitempty"`
}

type RecvTensorResponse struct {
	// The tensor as a proto.
	Tensor *tensorflow4.TensorProto `protobuf:"bytes,1,opt,name=tensor" json:"tensor,omitempty"`
	// If true, this tensor was the output of a dead node, and the
	// content is invalid.
	IsDead bool `protobuf:"varint,2,opt,name=is_dead,json=isDead" json:"is_dead,omitempty"`
	// The time at which tensor was available and started to be returned.
	SendStartMicros int64 `protobuf:"varint,3,opt,name=send_start_micros,json=sendStartMicros" json:"send_start_micros,omitempty"`
	// Optional additional information about how to receive the tensor,
	// e.g. in the event that `RecvTensorRequest.dma_ok` was true.
	TransportOptions *google_protobuf.Any `protobuf:"bytes,4,opt,name=transport_options,json=transportOptions" json:"transport_options,omitempty"`
}

type RegisterGraphRequest struct {
	// Subgraphs are scoped within one session.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
	// "graph_def" has the subgraph of nodes for this worker, with each node
	// having its device_name filled in.
	GraphDef *tensorflow10.GraphDef `protobuf:"bytes,2,opt,name=graph_def,json=graphDef" json:"graph_def,omitempty"`
	// True iff the graph (before partitioning) contains control flow nodes.
	//
	// As of 01/11/2015, this is no longer set by clients.
	HasControlFlow bool `protobuf:"varint,3,opt,name=has_control_flow,json=hasControlFlow" json:"has_control_flow,omitempty"`
	// Configuration options for the session in which this graph was created.
	GraphOptions *GraphOptions `protobuf:"bytes,4,opt,name=graph_options,json=graphOptions" json:"graph_options,omitempty"`
	// Field(s) used by TensorFlow Debugger (tfdbg).
	DebugOptions *DebugOptions `protobuf:"bytes,5,opt,name=debug_options,json=debugOptions" json:"debug_options,omitempty"`
}

type RegisterGraphResponse struct {
	// If the registration succeeds, returns an opaque graph_handle to
	// the master. The master calls RunGraph with graph_handle to
	// compute different steps.
	GraphHandle string `protobuf:"bytes,1,opt,name=graph_handle,json=graphHandle" json:"graph_handle,omitempty"`
}

type ResetRequest struct {
	// A list of container names, which may be empty.
	//
	// If 'container' is not empty, releases resoures in the given
	// containers in all devices.
	//
	// If 'container' is empty, releases resources in the default
	// container in all devices.
	Container []string `protobuf:"bytes,1,rep,name=container" json:"container,omitempty"`
	// 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.
	DeviceFilters []string `protobuf:"bytes,2,rep,name=device_filters,json=deviceFilters" json:"device_filters,omitempty"`
}

type ResetResponse struct {
}

type RewriterConfig struct {
	OptimizeTensorLayout bool `protobuf:"varint,1,opt,name=optimize_tensor_layout,json=optimizeTensorLayout" json:"optimize_tensor_layout,omitempty"`
	DisableModelPruning  bool `protobuf:"varint,2,opt,name=disable_model_pruning,json=disableModelPruning" json:"disable_model_pruning,omitempty"`
	ConstantFolding      bool `protobuf:"varint,3,opt,name=constant_folding,json=constantFolding" json:"constant_folding,omitempty"`
	// Configures memory optimization passes through the meta-optimizer. Has no
	// effect on manually requested memory optimization passes in the optimizers
	// field.
	MemoryOptimization RewriterConfig_MemOptType `` /* 151-byte string literal not displayed */
	// Configures AutoParallel optimization passes either through the
	// meta-optimizer or when manually specified through the optimizers field.
	AutoParallel *AutoParallelOptions `protobuf:"bytes,5,opt,name=auto_parallel,json=autoParallel" json:"auto_parallel,omitempty"`
	// 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.
	Optimizers []string `protobuf:"bytes,100,rep,name=optimizers" json:"optimizers,omitempty"`
}

type RewriterConfig_MemOptType int32

type RunGraphRequest struct {
	// 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.
	SessionHandle string `protobuf:"bytes,8,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
	// REQUIRED: graph_handle must be returned by a RegisterGraph call
	// to the same WorkerService.
	GraphHandle string `protobuf:"bytes,1,opt,name=graph_handle,json=graphHandle" json:"graph_handle,omitempty"`
	// 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.
	StepId int64 `protobuf:"varint,2,opt,name=step_id,json=stepId" json:"step_id,omitempty"`
	// Options for this step.
	ExecOpts *ExecutorOpts `protobuf:"bytes,5,opt,name=exec_opts,json=execOpts" json:"exec_opts,omitempty"`
	// Runs the graph.
	//
	// Sends the tensors in "send" into the graph before the run and
	// fetches the keys into `RunGraphResponse.recv` after the run.
	Send    []*NamedTensorProto `protobuf:"bytes,3,rep,name=send" json:"send,omitempty"`
	RecvKey []string            `protobuf:"bytes,4,rep,name=recv_key,json=recvKey" json:"recv_key,omitempty"`
	// True if the RunGraphRequest is a partial run request.
	IsPartial bool `protobuf:"varint,6,opt,name=is_partial,json=isPartial" json:"is_partial,omitempty"`
	// True if this is the last partial run request in a sequence of requests.
	IsLastPartialRun bool `protobuf:"varint,7,opt,name=is_last_partial_run,json=isLastPartialRun" json:"is_last_partial_run,omitempty"`
}

type RunGraphResponse struct {
	// A list of tensors corresponding to those requested by
	// `RunGraphRequest.recv_key`.
	Recv []*NamedTensorProto `protobuf:"bytes,1,rep,name=recv" json:"recv,omitempty"`
	// If the request asked for execution stats or cost graph, these are returned
	// here.
	StepStats *tensorflow13.StepStats   `protobuf:"bytes,2,opt,name=step_stats,json=stepStats" json:"step_stats,omitempty"`
	CostGraph *tensorflow2.CostGraphDef `protobuf:"bytes,3,opt,name=cost_graph,json=costGraph" json:"cost_graph,omitempty"`
}

type RunMetadata struct {
	// 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.
	StepStats *tensorflow13.StepStats `protobuf:"bytes,1,opt,name=step_stats,json=stepStats" json:"step_stats,omitempty"`
	// The cost graph for the computation defined by the run call.
	CostGraph *tensorflow2.CostGraphDef `protobuf:"bytes,2,opt,name=cost_graph,json=costGraph" json:"cost_graph,omitempty"`
	// Graphs of the partitions executed by executors.
	PartitionGraphs []*tensorflow10.GraphDef `protobuf:"bytes,3,rep,name=partition_graphs,json=partitionGraphs" json:"partition_graphs,omitempty"`
}

type RunOptions struct {
	TraceLevel RunOptions_TraceLevel `protobuf:"varint,1,opt,name=trace_level,json=traceLevel,enum=tensorflow.RunOptions_TraceLevel" json:"trace_level,omitempty"`
	// Time to wait for operation to complete in milliseconds.
	TimeoutInMs int64 `protobuf:"varint,2,opt,name=timeout_in_ms,json=timeoutInMs" json:"timeout_in_ms,omitempty"`
	// The thread pool to use, if session_inter_op_thread_pool is configured.
	InterOpThreadPool int32 `protobuf:"varint,3,opt,name=inter_op_thread_pool,json=interOpThreadPool" json:"inter_op_thread_pool,omitempty"`
	// Whether the partition graph(s) executed by the executor(s) should be
	// outputted via RunMetadata.
	OutputPartitionGraphs bool `protobuf:"varint,5,opt,name=output_partition_graphs,json=outputPartitionGraphs" json:"output_partition_graphs,omitempty"`
	// EXPERIMENTAL.  Options used to initialize DebuggerState, if enabled.
	DebugOptions *DebugOptions `protobuf:"bytes,6,opt,name=debug_options,json=debugOptions" json:"debug_options,omitempty"`
}

type RunOptions_TraceLevel int32

type RunStepRequest struct {
	// REQUIRED: session_handle must be returned by a CreateSession call
	// to the same master service.
	SessionHandle string `protobuf:"bytes,1,opt,name=session_handle,json=sessionHandle" json:"session_handle,omitempty"`
	// Tensors to be fed in the step. Each feed is a named tensor.
	Feed []*NamedTensorProto `protobuf:"bytes,2,rep,name=feed" json:"feed,omitempty"`
	// 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.
	Fetch []string `protobuf:"bytes,3,rep,name=fetch" json:"fetch,omitempty"`
	// Target Nodes. A list of node names. The named nodes will be run
	// to but their outputs will not be fetched.
	Target []string `protobuf:"bytes,4,rep,name=target" json:"target,omitempty"`
	// Options for the run call.
	Options *RunOptions `protobuf:"bytes,5,opt,name=options" json:"options,omitempty"`
	// Partial run handle (optional). If specified, this will be a partial run
	// execution, run up to the specified fetches.
	PartialRunHandle string `protobuf:"bytes,6,opt,name=partial_run_handle,json=partialRunHandle" json:"partial_run_handle,omitempty"`
}

type RunStepResponse struct {
	// NOTE: The order of the returned tensors may or may not match
	// the fetch order specified in RunStepRequest.
	Tensor []*NamedTensorProto `protobuf:"bytes,1,rep,name=tensor" json:"tensor,omitempty"`
	// Returned metadata if requested in the options.
	Metadata *RunMetadata `protobuf:"bytes,2,opt,name=metadata" json:"metadata,omitempty"`
}

type SavedModel struct {
	// 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.
	SavedModelSchemaVersion int64 `` /* 128-byte string literal not displayed */
	// One or more MetaGraphs.
	MetaGraphs []*MetaGraphDef `protobuf:"bytes,2,rep,name=meta_graphs,json=metaGraphs" json:"meta_graphs,omitempty"`
}