org.tensorflow.framework

Class ConfigProto.Builder

java.lang.Object

org.nd4j.shade.protobuf.AbstractMessageLite.Builder

org.nd4j.shade.protobuf.AbstractMessage.Builder<BuilderType>

org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

org.tensorflow.framework.ConfigProto.Builder

All Implemented Interfaces:

Cloneable, org.nd4j.shade.protobuf.Message.Builder, org.nd4j.shade.protobuf.MessageLite.Builder, org.nd4j.shade.protobuf.MessageLiteOrBuilder, org.nd4j.shade.protobuf.MessageOrBuilder, ConfigProtoOrBuilder

Enclosing class:

ConfigProto

public static final class ConfigProto.Builder
extends org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>
implements ConfigProtoOrBuilder

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

Protobuf type tensorflow.ConfigProto

Method Summary

Modifier and Type	Method and Description
ConfigProto.Builder	addAllDeviceFilters(Iterable<String> values) When any filters are present sessions will ignore all devices which do not match the filters.
ConfigProto.Builder	addAllSessionInterOpThreadPool(Iterable<? extends ThreadPoolOptionProto> values) This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto.Builder	addDeviceFilters(String value) When any filters are present sessions will ignore all devices which do not match the filters.
ConfigProto.Builder	addDeviceFiltersBytes(org.nd4j.shade.protobuf.ByteString value) When any filters are present sessions will ignore all devices which do not match the filters.
ConfigProto.Builder	addRepeatedField(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field, Object value)
ConfigProto.Builder	addSessionInterOpThreadPool(int index, ThreadPoolOptionProto.Builder builderForValue) This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto.Builder	addSessionInterOpThreadPool(int index, ThreadPoolOptionProto value) This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto.Builder	addSessionInterOpThreadPool(ThreadPoolOptionProto.Builder builderForValue) This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto.Builder	addSessionInterOpThreadPool(ThreadPoolOptionProto value) This option is experimental - it may be replaced with a different mechanism in the future.
ThreadPoolOptionProto.Builder	addSessionInterOpThreadPoolBuilder() This option is experimental - it may be replaced with a different mechanism in the future.
ThreadPoolOptionProto.Builder	addSessionInterOpThreadPoolBuilder(int index) This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto	build()
ConfigProto	buildPartial()
ConfigProto.Builder	clear()
ConfigProto.Builder	clearAllowSoftPlacement() Whether soft placement is allowed.
ConfigProto.Builder	clearClusterDef() Optional list of all workers to use in this session.
ConfigProto.Builder	clearDeviceCount()
ConfigProto.Builder	clearDeviceFilters() When any filters are present sessions will ignore all devices which do not match the filters.
ConfigProto.Builder	clearExperimental() .tensorflow.ConfigProto.Experimental experimental = 16;
ConfigProto.Builder	clearField(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field)
ConfigProto.Builder	clearGpuOptions() Options that apply to all GPUs.
ConfigProto.Builder	clearGraphOptions() Options that apply to all graphs.
ConfigProto.Builder	clearInterOpParallelismThreads() Nodes that perform blocking operations are enqueued on a pool of inter_op_parallelism_threads available in each process.
ConfigProto.Builder	clearIntraOpParallelismThreads() The execution of an individual op (for some op types) can be parallelized on a pool of intra_op_parallelism_threads.
ConfigProto.Builder	clearIsolateSessionState() If true, any resources such as Variables used in the session will not be shared with other sessions.
ConfigProto.Builder	clearLogDevicePlacement() Whether device placements should be logged.
ConfigProto.Builder	clearOneof(org.nd4j.shade.protobuf.Descriptors.OneofDescriptor oneof)
ConfigProto.Builder	clearOperationTimeoutInMs() Global timeout for all blocking operations in this session.
ConfigProto.Builder	clearPlacementPeriod() 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).
ConfigProto.Builder	clearRpcOptions() Options that apply when this session uses the distributed runtime.
ConfigProto.Builder	clearSessionInterOpThreadPool() This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto.Builder	clearUsePerSessionThreads() If true, use a new set of threads for this session rather than the global pool of threads.
ConfigProto.Builder	clone()
boolean	containsDeviceCount(String key) Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use.
boolean	getAllowSoftPlacement() Whether soft placement is allowed.
ClusterDef	getClusterDef() Optional list of all workers to use in this session.
ClusterDef.Builder	getClusterDefBuilder() Optional list of all workers to use in this session.
ClusterDefOrBuilder	getClusterDefOrBuilder() Optional list of all workers to use in this session.
ConfigProto	getDefaultInstanceForType()
static org.nd4j.shade.protobuf.Descriptors.Descriptor	getDescriptor()
org.nd4j.shade.protobuf.Descriptors.Descriptor	getDescriptorForType()
Map<String,Integer>	getDeviceCount() Deprecated.
int	getDeviceCountCount() Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use.
Map<String,Integer>	getDeviceCountMap() Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use.
int	getDeviceCountOrDefault(String key, int defaultValue) Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use.
int	getDeviceCountOrThrow(String key) Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use.
String	getDeviceFilters(int index) When any filters are present sessions will ignore all devices which do not match the filters.
org.nd4j.shade.protobuf.ByteString	getDeviceFiltersBytes(int index) When any filters are present sessions will ignore all devices which do not match the filters.
int	getDeviceFiltersCount() When any filters are present sessions will ignore all devices which do not match the filters.
org.nd4j.shade.protobuf.ProtocolStringList	getDeviceFiltersList() When any filters are present sessions will ignore all devices which do not match the filters.
ConfigProto.Experimental	getExperimental() .tensorflow.ConfigProto.Experimental experimental = 16;
ConfigProto.Experimental.Builder	getExperimentalBuilder() .tensorflow.ConfigProto.Experimental experimental = 16;
ConfigProto.ExperimentalOrBuilder	getExperimentalOrBuilder() .tensorflow.ConfigProto.Experimental experimental = 16;
GPUOptions	getGpuOptions() Options that apply to all GPUs.
GPUOptions.Builder	getGpuOptionsBuilder() Options that apply to all GPUs.
GPUOptionsOrBuilder	getGpuOptionsOrBuilder() Options that apply to all GPUs.
GraphOptions	getGraphOptions() Options that apply to all graphs.
GraphOptions.Builder	getGraphOptionsBuilder() Options that apply to all graphs.
GraphOptionsOrBuilder	getGraphOptionsOrBuilder() Options that apply to all graphs.
int	getInterOpParallelismThreads() Nodes that perform blocking operations are enqueued on a pool of inter_op_parallelism_threads available in each process.
int	getIntraOpParallelismThreads() The execution of an individual op (for some op types) can be parallelized on a pool of intra_op_parallelism_threads.
boolean	getIsolateSessionState() If true, any resources such as Variables used in the session will not be shared with other sessions.
boolean	getLogDevicePlacement() Whether device placements should be logged.
Map<String,Integer>	getMutableDeviceCount() Deprecated.
long	getOperationTimeoutInMs() Global timeout for all blocking operations in this session.
int	getPlacementPeriod() 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).
RPCOptions	getRpcOptions() Options that apply when this session uses the distributed runtime.
RPCOptions.Builder	getRpcOptionsBuilder() Options that apply when this session uses the distributed runtime.
RPCOptionsOrBuilder	getRpcOptionsOrBuilder() Options that apply when this session uses the distributed runtime.
ThreadPoolOptionProto	getSessionInterOpThreadPool(int index) This option is experimental - it may be replaced with a different mechanism in the future.
ThreadPoolOptionProto.Builder	getSessionInterOpThreadPoolBuilder(int index) This option is experimental - it may be replaced with a different mechanism in the future.
List<ThreadPoolOptionProto.Builder>	getSessionInterOpThreadPoolBuilderList() This option is experimental - it may be replaced with a different mechanism in the future.
int	getSessionInterOpThreadPoolCount() This option is experimental - it may be replaced with a different mechanism in the future.
List<ThreadPoolOptionProto>	getSessionInterOpThreadPoolList() This option is experimental - it may be replaced with a different mechanism in the future.
ThreadPoolOptionProtoOrBuilder	getSessionInterOpThreadPoolOrBuilder(int index) This option is experimental - it may be replaced with a different mechanism in the future.
List<? extends ThreadPoolOptionProtoOrBuilder>	getSessionInterOpThreadPoolOrBuilderList() This option is experimental - it may be replaced with a different mechanism in the future.
boolean	getUsePerSessionThreads() If true, use a new set of threads for this session rather than the global pool of threads.
boolean	hasClusterDef() Optional list of all workers to use in this session.
boolean	hasExperimental() .tensorflow.ConfigProto.Experimental experimental = 16;
boolean	hasGpuOptions() Options that apply to all GPUs.
boolean	hasGraphOptions() Options that apply to all graphs.
boolean	hasRpcOptions() Options that apply when this session uses the distributed runtime.
protected org.nd4j.shade.protobuf.GeneratedMessageV3.FieldAccessorTable	internalGetFieldAccessorTable()
protected org.nd4j.shade.protobuf.MapField	internalGetMapField(int number)
protected org.nd4j.shade.protobuf.MapField	internalGetMutableMapField(int number)
boolean	isInitialized()
ConfigProto.Builder	mergeClusterDef(ClusterDef value) Optional list of all workers to use in this session.
ConfigProto.Builder	mergeExperimental(ConfigProto.Experimental value) .tensorflow.ConfigProto.Experimental experimental = 16;
ConfigProto.Builder	mergeFrom(org.nd4j.shade.protobuf.CodedInputStream input, org.nd4j.shade.protobuf.ExtensionRegistryLite extensionRegistry)
ConfigProto.Builder	mergeFrom(ConfigProto other)
ConfigProto.Builder	mergeFrom(org.nd4j.shade.protobuf.Message other)
ConfigProto.Builder	mergeGpuOptions(GPUOptions value) Options that apply to all GPUs.
ConfigProto.Builder	mergeGraphOptions(GraphOptions value) Options that apply to all graphs.
ConfigProto.Builder	mergeRpcOptions(RPCOptions value) Options that apply when this session uses the distributed runtime.
ConfigProto.Builder	mergeUnknownFields(org.nd4j.shade.protobuf.UnknownFieldSet unknownFields)
ConfigProto.Builder	putAllDeviceCount(Map<String,Integer> values) Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use.
ConfigProto.Builder	putDeviceCount(String key, int value) Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use.
ConfigProto.Builder	removeDeviceCount(String key) Map from device type name (e.g., "CPU" or "GPU" ) to maximum number of devices of that type to use.
ConfigProto.Builder	removeSessionInterOpThreadPool(int index) This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto.Builder	setAllowSoftPlacement(boolean value) Whether soft placement is allowed.
ConfigProto.Builder	setClusterDef(ClusterDef.Builder builderForValue) Optional list of all workers to use in this session.
ConfigProto.Builder	setClusterDef(ClusterDef value) Optional list of all workers to use in this session.
ConfigProto.Builder	setDeviceFilters(int index, String value) When any filters are present sessions will ignore all devices which do not match the filters.
ConfigProto.Builder	setExperimental(ConfigProto.Experimental.Builder builderForValue) .tensorflow.ConfigProto.Experimental experimental = 16;
ConfigProto.Builder	setExperimental(ConfigProto.Experimental value) .tensorflow.ConfigProto.Experimental experimental = 16;
ConfigProto.Builder	setField(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field, Object value)
ConfigProto.Builder	setGpuOptions(GPUOptions.Builder builderForValue) Options that apply to all GPUs.
ConfigProto.Builder	setGpuOptions(GPUOptions value) Options that apply to all GPUs.
ConfigProto.Builder	setGraphOptions(GraphOptions.Builder builderForValue) Options that apply to all graphs.
ConfigProto.Builder	setGraphOptions(GraphOptions value) Options that apply to all graphs.
ConfigProto.Builder	setInterOpParallelismThreads(int value) Nodes that perform blocking operations are enqueued on a pool of inter_op_parallelism_threads available in each process.
ConfigProto.Builder	setIntraOpParallelismThreads(int value) The execution of an individual op (for some op types) can be parallelized on a pool of intra_op_parallelism_threads.
ConfigProto.Builder	setIsolateSessionState(boolean value) If true, any resources such as Variables used in the session will not be shared with other sessions.
ConfigProto.Builder	setLogDevicePlacement(boolean value) Whether device placements should be logged.
ConfigProto.Builder	setOperationTimeoutInMs(long value) Global timeout for all blocking operations in this session.
ConfigProto.Builder	setPlacementPeriod(int value) 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).
ConfigProto.Builder	setRepeatedField(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field, int index, Object value)
ConfigProto.Builder	setRpcOptions(RPCOptions.Builder builderForValue) Options that apply when this session uses the distributed runtime.
ConfigProto.Builder	setRpcOptions(RPCOptions value) Options that apply when this session uses the distributed runtime.
ConfigProto.Builder	setSessionInterOpThreadPool(int index, ThreadPoolOptionProto.Builder builderForValue) This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto.Builder	setSessionInterOpThreadPool(int index, ThreadPoolOptionProto value) This option is experimental - it may be replaced with a different mechanism in the future.
ConfigProto.Builder	setUnknownFields(org.nd4j.shade.protobuf.UnknownFieldSet unknownFields)
ConfigProto.Builder	setUsePerSessionThreads(boolean value) If true, use a new set of threads for this session rather than the global pool of threads.

Methods inherited from class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder

getAllFields, getField, getFieldBuilder, getOneofFieldDescriptor, getParentForChildren, getRepeatedField, getRepeatedFieldBuilder, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof, isClean, markClean, newBuilderForField, onBuilt, onChanged, setUnknownFieldsProto3

Methods inherited from class org.nd4j.shade.protobuf.AbstractMessage.Builder

findInitializationErrors, getInitializationErrorString, internalMergeFrom, mergeDelimitedFrom, mergeDelimitedFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, mergeFrom, newUninitializedMessageException, toString

Methods inherited from class org.nd4j.shade.protobuf.AbstractMessageLite.Builder

addAll, addAll, mergeFrom, newUninitializedMessageException

Methods inherited from class java.lang.Object

equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.nd4j.shade.protobuf.MessageOrBuilder

findInitializationErrors, getAllFields, getField, getInitializationErrorString, getOneofFieldDescriptor, getRepeatedField, getRepeatedFieldCount, getUnknownFields, hasField, hasOneof

Methods inherited from interface org.nd4j.shade.protobuf.MessageLite.Builder

mergeFrom

Method Detail

getDescriptor

public static final org.nd4j.shade.protobuf.Descriptors.Descriptor getDescriptor()

internalGetMapField

protected org.nd4j.shade.protobuf.MapField internalGetMapField(int number)

Overrides:

internalGetMapField in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

internalGetMutableMapField

protected org.nd4j.shade.protobuf.MapField internalGetMutableMapField(int number)

Overrides:

internalGetMutableMapField in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

internalGetFieldAccessorTable

protected org.nd4j.shade.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()

Specified by:

internalGetFieldAccessorTable in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

clear

public ConfigProto.Builder clear()

Specified by:

clear in interface org.nd4j.shade.protobuf.Message.Builder

Specified by:

clear in interface org.nd4j.shade.protobuf.MessageLite.Builder

Overrides:

clear in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

getDescriptorForType

public org.nd4j.shade.protobuf.Descriptors.Descriptor getDescriptorForType()

Specified by:

getDescriptorForType in interface org.nd4j.shade.protobuf.Message.Builder

Specified by:

getDescriptorForType in interface org.nd4j.shade.protobuf.MessageOrBuilder

Overrides:

getDescriptorForType in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

getDefaultInstanceForType

public ConfigProto getDefaultInstanceForType()

Specified by:

getDefaultInstanceForType in interface org.nd4j.shade.protobuf.MessageLiteOrBuilder

Specified by:

getDefaultInstanceForType in interface org.nd4j.shade.protobuf.MessageOrBuilder

build

public ConfigProto build()

Specified by:

build in interface org.nd4j.shade.protobuf.Message.Builder

Specified by:

build in interface org.nd4j.shade.protobuf.MessageLite.Builder

buildPartial

public ConfigProto buildPartial()

Specified by:

buildPartial in interface org.nd4j.shade.protobuf.Message.Builder

Specified by:

buildPartial in interface org.nd4j.shade.protobuf.MessageLite.Builder

clone

public ConfigProto.Builder clone()

Specified by:

clone in interface org.nd4j.shade.protobuf.Message.Builder

Specified by:

clone in interface org.nd4j.shade.protobuf.MessageLite.Builder

Overrides:

clone in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

setField

public ConfigProto.Builder setField(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field,
                                    Object value)

Specified by:

setField in interface org.nd4j.shade.protobuf.Message.Builder

Overrides:

setField in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

clearField

public ConfigProto.Builder clearField(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field)

Specified by:

clearField in interface org.nd4j.shade.protobuf.Message.Builder

Overrides:

clearField in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

clearOneof

public ConfigProto.Builder clearOneof(org.nd4j.shade.protobuf.Descriptors.OneofDescriptor oneof)

Specified by:

clearOneof in interface org.nd4j.shade.protobuf.Message.Builder

Overrides:

clearOneof in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

setRepeatedField

public ConfigProto.Builder setRepeatedField(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field,
                                            int index,
                                            Object value)

Specified by:

setRepeatedField in interface org.nd4j.shade.protobuf.Message.Builder

Overrides:

setRepeatedField in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

addRepeatedField

public ConfigProto.Builder addRepeatedField(org.nd4j.shade.protobuf.Descriptors.FieldDescriptor field,
                                            Object value)

Specified by:

addRepeatedField in interface org.nd4j.shade.protobuf.Message.Builder

Overrides:

addRepeatedField in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

mergeFrom

public ConfigProto.Builder mergeFrom(org.nd4j.shade.protobuf.Message other)

Specified by:

mergeFrom in interface org.nd4j.shade.protobuf.Message.Builder

Overrides:

mergeFrom in class org.nd4j.shade.protobuf.AbstractMessage.Builder<ConfigProto.Builder>

mergeFrom

public ConfigProto.Builder mergeFrom(ConfigProto other)

isInitialized

public final boolean isInitialized()

Specified by:

isInitialized in interface org.nd4j.shade.protobuf.MessageLiteOrBuilder

Overrides:

isInitialized in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

mergeFrom

public ConfigProto.Builder mergeFrom(org.nd4j.shade.protobuf.CodedInputStream input,
                                     org.nd4j.shade.protobuf.ExtensionRegistryLite extensionRegistry)
                              throws IOException

Specified by:

mergeFrom in interface org.nd4j.shade.protobuf.Message.Builder

Specified by:

mergeFrom in interface org.nd4j.shade.protobuf.MessageLite.Builder

Overrides:

mergeFrom in class org.nd4j.shade.protobuf.AbstractMessage.Builder<ConfigProto.Builder>

Throws:

IOException

getDeviceCountCount

public int getDeviceCountCount()

Description copied from interface: ConfigProtoOrBuilder

 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.
 

map<string, int32> device_count = 1;

Specified by:

getDeviceCountCount in interface ConfigProtoOrBuilder

containsDeviceCount

public boolean containsDeviceCount(String key)

 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.
 

map<string, int32> device_count = 1;

Specified by:

containsDeviceCount in interface ConfigProtoOrBuilder

getDeviceCount

@Deprecated
public Map<String,Integer> getDeviceCount()

Deprecated.

Use getDeviceCountMap() instead.

Specified by:

getDeviceCount in interface ConfigProtoOrBuilder

getDeviceCountMap

public Map<String,Integer> getDeviceCountMap()

 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.
 

map<string, int32> device_count = 1;

Specified by:

getDeviceCountMap in interface ConfigProtoOrBuilder

getDeviceCountOrDefault

public int getDeviceCountOrDefault(String key,
                                   int defaultValue)

 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.
 

map<string, int32> device_count = 1;

Specified by:

getDeviceCountOrDefault in interface ConfigProtoOrBuilder

getDeviceCountOrThrow

public int getDeviceCountOrThrow(String key)

 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.
 

map<string, int32> device_count = 1;

Specified by:

getDeviceCountOrThrow in interface ConfigProtoOrBuilder

clearDeviceCount

public ConfigProto.Builder clearDeviceCount()

removeDeviceCount

public ConfigProto.Builder removeDeviceCount(String key)

 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.
 

map<string, int32> device_count = 1;

getMutableDeviceCount

@Deprecated
public Map<String,Integer> getMutableDeviceCount()

Deprecated.

Use alternate mutation accessors instead.

putDeviceCount

public ConfigProto.Builder putDeviceCount(String key,
                                          int value)

 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.
 

map<string, int32> device_count = 1;

putAllDeviceCount

public ConfigProto.Builder putAllDeviceCount(Map<String,Integer> values)

 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.
 

map<string, int32> device_count = 1;

getIntraOpParallelismThreads

public int getIntraOpParallelismThreads()

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

int32 intra_op_parallelism_threads = 2;

Specified by:

getIntraOpParallelismThreads in interface ConfigProtoOrBuilder

setIntraOpParallelismThreads

public ConfigProto.Builder setIntraOpParallelismThreads(int value)

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

int32 intra_op_parallelism_threads = 2;

clearIntraOpParallelismThreads

public ConfigProto.Builder clearIntraOpParallelismThreads()

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

int32 intra_op_parallelism_threads = 2;

getInterOpParallelismThreads

public int getInterOpParallelismThreads()

 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.
 

int32 inter_op_parallelism_threads = 5;

Specified by:

getInterOpParallelismThreads in interface ConfigProtoOrBuilder

setInterOpParallelismThreads

public ConfigProto.Builder setInterOpParallelismThreads(int value)

 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.
 

int32 inter_op_parallelism_threads = 5;

clearInterOpParallelismThreads

public ConfigProto.Builder clearInterOpParallelismThreads()

 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.
 

int32 inter_op_parallelism_threads = 5;

getUsePerSessionThreads

public boolean getUsePerSessionThreads()

 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.
 

bool use_per_session_threads = 9;

Specified by:

getUsePerSessionThreads in interface ConfigProtoOrBuilder

setUsePerSessionThreads

public ConfigProto.Builder setUsePerSessionThreads(boolean value)

 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.
 

bool use_per_session_threads = 9;

clearUsePerSessionThreads

public ConfigProto.Builder clearUsePerSessionThreads()

 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.
 

bool use_per_session_threads = 9;

getSessionInterOpThreadPoolList

public List<ThreadPoolOptionProto> getSessionInterOpThreadPoolList()

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

Specified by:

getSessionInterOpThreadPoolList in interface ConfigProtoOrBuilder

getSessionInterOpThreadPoolCount

public int getSessionInterOpThreadPoolCount()

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

Specified by:

getSessionInterOpThreadPoolCount in interface ConfigProtoOrBuilder

getSessionInterOpThreadPool

public ThreadPoolOptionProto getSessionInterOpThreadPool(int index)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

Specified by:

getSessionInterOpThreadPool in interface ConfigProtoOrBuilder

setSessionInterOpThreadPool

public ConfigProto.Builder setSessionInterOpThreadPool(int index,
                                                       ThreadPoolOptionProto value)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

setSessionInterOpThreadPool

public ConfigProto.Builder setSessionInterOpThreadPool(int index,
                                                       ThreadPoolOptionProto.Builder builderForValue)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

addSessionInterOpThreadPool

public ConfigProto.Builder addSessionInterOpThreadPool(ThreadPoolOptionProto value)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

addSessionInterOpThreadPool

public ConfigProto.Builder addSessionInterOpThreadPool(int index,
                                                       ThreadPoolOptionProto value)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

addSessionInterOpThreadPool

public ConfigProto.Builder addSessionInterOpThreadPool(ThreadPoolOptionProto.Builder builderForValue)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

addSessionInterOpThreadPool

public ConfigProto.Builder addSessionInterOpThreadPool(int index,
                                                       ThreadPoolOptionProto.Builder builderForValue)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

addAllSessionInterOpThreadPool

public ConfigProto.Builder addAllSessionInterOpThreadPool(Iterable<? extends ThreadPoolOptionProto> values)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

clearSessionInterOpThreadPool

public ConfigProto.Builder clearSessionInterOpThreadPool()

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

removeSessionInterOpThreadPool

public ConfigProto.Builder removeSessionInterOpThreadPool(int index)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

getSessionInterOpThreadPoolBuilder

public ThreadPoolOptionProto.Builder getSessionInterOpThreadPoolBuilder(int index)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

getSessionInterOpThreadPoolOrBuilder

public ThreadPoolOptionProtoOrBuilder getSessionInterOpThreadPoolOrBuilder(int index)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

Specified by:

getSessionInterOpThreadPoolOrBuilder in interface ConfigProtoOrBuilder

getSessionInterOpThreadPoolOrBuilderList

public List<? extends ThreadPoolOptionProtoOrBuilder> getSessionInterOpThreadPoolOrBuilderList()

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

Specified by:

getSessionInterOpThreadPoolOrBuilderList in interface ConfigProtoOrBuilder

addSessionInterOpThreadPoolBuilder

public ThreadPoolOptionProto.Builder addSessionInterOpThreadPoolBuilder()

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

addSessionInterOpThreadPoolBuilder

public ThreadPoolOptionProto.Builder addSessionInterOpThreadPoolBuilder(int index)

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

getSessionInterOpThreadPoolBuilderList

public List<ThreadPoolOptionProto.Builder> getSessionInterOpThreadPoolBuilderList()

 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.
 

repeated .tensorflow.ThreadPoolOptionProto session_inter_op_thread_pool = 12;

getPlacementPeriod

public int getPlacementPeriod()

 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).
 

int32 placement_period = 3;

Specified by:

getPlacementPeriod in interface ConfigProtoOrBuilder

setPlacementPeriod

public ConfigProto.Builder setPlacementPeriod(int value)

 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).
 

int32 placement_period = 3;

clearPlacementPeriod

public ConfigProto.Builder clearPlacementPeriod()

 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).
 

int32 placement_period = 3;

getDeviceFiltersList

public org.nd4j.shade.protobuf.ProtocolStringList getDeviceFiltersList()

 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.
 

repeated string device_filters = 4;

Specified by:

getDeviceFiltersList in interface ConfigProtoOrBuilder

getDeviceFiltersCount

public int getDeviceFiltersCount()

 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.
 

repeated string device_filters = 4;

Specified by:

getDeviceFiltersCount in interface ConfigProtoOrBuilder

getDeviceFilters

public String getDeviceFilters(int index)

 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.
 

repeated string device_filters = 4;

Specified by:

getDeviceFilters in interface ConfigProtoOrBuilder

getDeviceFiltersBytes

public org.nd4j.shade.protobuf.ByteString getDeviceFiltersBytes(int index)

 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.
 

repeated string device_filters = 4;

Specified by:

getDeviceFiltersBytes in interface ConfigProtoOrBuilder

setDeviceFilters

public ConfigProto.Builder setDeviceFilters(int index,
                                            String value)

 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.
 

repeated string device_filters = 4;

addDeviceFilters

public ConfigProto.Builder addDeviceFilters(String value)

 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.
 

repeated string device_filters = 4;

addAllDeviceFilters

public ConfigProto.Builder addAllDeviceFilters(Iterable<String> values)

 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.
 

repeated string device_filters = 4;

clearDeviceFilters

public ConfigProto.Builder clearDeviceFilters()

 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.
 

repeated string device_filters = 4;

addDeviceFiltersBytes

public ConfigProto.Builder addDeviceFiltersBytes(org.nd4j.shade.protobuf.ByteString value)

 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.
 

repeated string device_filters = 4;

hasGpuOptions

public boolean hasGpuOptions()

 Options that apply to all GPUs.
 

.tensorflow.GPUOptions gpu_options = 6;

Specified by:

hasGpuOptions in interface ConfigProtoOrBuilder

getGpuOptions

public GPUOptions getGpuOptions()

 Options that apply to all GPUs.
 

.tensorflow.GPUOptions gpu_options = 6;

Specified by:

getGpuOptions in interface ConfigProtoOrBuilder

setGpuOptions

public ConfigProto.Builder setGpuOptions(GPUOptions value)

 Options that apply to all GPUs.
 

.tensorflow.GPUOptions gpu_options = 6;

setGpuOptions

public ConfigProto.Builder setGpuOptions(GPUOptions.Builder builderForValue)

 Options that apply to all GPUs.
 

.tensorflow.GPUOptions gpu_options = 6;

mergeGpuOptions

public ConfigProto.Builder mergeGpuOptions(GPUOptions value)

 Options that apply to all GPUs.
 

.tensorflow.GPUOptions gpu_options = 6;

clearGpuOptions

public ConfigProto.Builder clearGpuOptions()

 Options that apply to all GPUs.
 

.tensorflow.GPUOptions gpu_options = 6;

getGpuOptionsBuilder

public GPUOptions.Builder getGpuOptionsBuilder()

 Options that apply to all GPUs.
 

.tensorflow.GPUOptions gpu_options = 6;

getGpuOptionsOrBuilder

public GPUOptionsOrBuilder getGpuOptionsOrBuilder()

 Options that apply to all GPUs.
 

.tensorflow.GPUOptions gpu_options = 6;

Specified by:

getGpuOptionsOrBuilder in interface ConfigProtoOrBuilder

getAllowSoftPlacement

public boolean getAllowSoftPlacement()

 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 allow_soft_placement = 7;

Specified by:

getAllowSoftPlacement in interface ConfigProtoOrBuilder

setAllowSoftPlacement

public ConfigProto.Builder setAllowSoftPlacement(boolean value)

 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 allow_soft_placement = 7;

clearAllowSoftPlacement

public ConfigProto.Builder clearAllowSoftPlacement()

 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 allow_soft_placement = 7;

getLogDevicePlacement

public boolean getLogDevicePlacement()

 Whether device placements should be logged.
 

bool log_device_placement = 8;

Specified by:

getLogDevicePlacement in interface ConfigProtoOrBuilder

setLogDevicePlacement

public ConfigProto.Builder setLogDevicePlacement(boolean value)

 Whether device placements should be logged.
 

bool log_device_placement = 8;

clearLogDevicePlacement

public ConfigProto.Builder clearLogDevicePlacement()

 Whether device placements should be logged.
 

bool log_device_placement = 8;

hasGraphOptions

public boolean hasGraphOptions()

 Options that apply to all graphs.
 

.tensorflow.GraphOptions graph_options = 10;

Specified by:

hasGraphOptions in interface ConfigProtoOrBuilder

getGraphOptions

public GraphOptions getGraphOptions()

 Options that apply to all graphs.
 

.tensorflow.GraphOptions graph_options = 10;

Specified by:

getGraphOptions in interface ConfigProtoOrBuilder

setGraphOptions

public ConfigProto.Builder setGraphOptions(GraphOptions value)

 Options that apply to all graphs.
 

.tensorflow.GraphOptions graph_options = 10;

setGraphOptions

public ConfigProto.Builder setGraphOptions(GraphOptions.Builder builderForValue)

 Options that apply to all graphs.
 

.tensorflow.GraphOptions graph_options = 10;

mergeGraphOptions

public ConfigProto.Builder mergeGraphOptions(GraphOptions value)

 Options that apply to all graphs.
 

.tensorflow.GraphOptions graph_options = 10;

clearGraphOptions

public ConfigProto.Builder clearGraphOptions()

 Options that apply to all graphs.
 

.tensorflow.GraphOptions graph_options = 10;

getGraphOptionsBuilder

public GraphOptions.Builder getGraphOptionsBuilder()

 Options that apply to all graphs.
 

.tensorflow.GraphOptions graph_options = 10;

getGraphOptionsOrBuilder

public GraphOptionsOrBuilder getGraphOptionsOrBuilder()

 Options that apply to all graphs.
 

.tensorflow.GraphOptions graph_options = 10;

Specified by:

getGraphOptionsOrBuilder in interface ConfigProtoOrBuilder

getOperationTimeoutInMs

public long getOperationTimeoutInMs()

 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.
 

int64 operation_timeout_in_ms = 11;

Specified by:

getOperationTimeoutInMs in interface ConfigProtoOrBuilder

setOperationTimeoutInMs

public ConfigProto.Builder setOperationTimeoutInMs(long value)

 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.
 

int64 operation_timeout_in_ms = 11;

clearOperationTimeoutInMs

public ConfigProto.Builder clearOperationTimeoutInMs()

 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.
 

int64 operation_timeout_in_ms = 11;

hasRpcOptions

public boolean hasRpcOptions()

 Options that apply when this session uses the distributed runtime.
 

.tensorflow.RPCOptions rpc_options = 13;

Specified by:

hasRpcOptions in interface ConfigProtoOrBuilder

getRpcOptions

public RPCOptions getRpcOptions()

 Options that apply when this session uses the distributed runtime.
 

.tensorflow.RPCOptions rpc_options = 13;

Specified by:

getRpcOptions in interface ConfigProtoOrBuilder

setRpcOptions

public ConfigProto.Builder setRpcOptions(RPCOptions value)

 Options that apply when this session uses the distributed runtime.
 

.tensorflow.RPCOptions rpc_options = 13;

setRpcOptions

public ConfigProto.Builder setRpcOptions(RPCOptions.Builder builderForValue)

 Options that apply when this session uses the distributed runtime.
 

.tensorflow.RPCOptions rpc_options = 13;

mergeRpcOptions

public ConfigProto.Builder mergeRpcOptions(RPCOptions value)

 Options that apply when this session uses the distributed runtime.
 

.tensorflow.RPCOptions rpc_options = 13;

clearRpcOptions

public ConfigProto.Builder clearRpcOptions()

 Options that apply when this session uses the distributed runtime.
 

.tensorflow.RPCOptions rpc_options = 13;

getRpcOptionsBuilder

public RPCOptions.Builder getRpcOptionsBuilder()

 Options that apply when this session uses the distributed runtime.
 

.tensorflow.RPCOptions rpc_options = 13;

getRpcOptionsOrBuilder

public RPCOptionsOrBuilder getRpcOptionsOrBuilder()

 Options that apply when this session uses the distributed runtime.
 

.tensorflow.RPCOptions rpc_options = 13;

Specified by:

getRpcOptionsOrBuilder in interface ConfigProtoOrBuilder

hasClusterDef

public boolean hasClusterDef()

 Optional list of all workers to use in this session.
 

.tensorflow.ClusterDef cluster_def = 14;

Specified by:

hasClusterDef in interface ConfigProtoOrBuilder

getClusterDef

public ClusterDef getClusterDef()

 Optional list of all workers to use in this session.
 

.tensorflow.ClusterDef cluster_def = 14;

Specified by:

getClusterDef in interface ConfigProtoOrBuilder

setClusterDef

public ConfigProto.Builder setClusterDef(ClusterDef value)

 Optional list of all workers to use in this session.
 

.tensorflow.ClusterDef cluster_def = 14;

setClusterDef

public ConfigProto.Builder setClusterDef(ClusterDef.Builder builderForValue)

 Optional list of all workers to use in this session.
 

.tensorflow.ClusterDef cluster_def = 14;

mergeClusterDef

public ConfigProto.Builder mergeClusterDef(ClusterDef value)

 Optional list of all workers to use in this session.
 

.tensorflow.ClusterDef cluster_def = 14;

clearClusterDef

public ConfigProto.Builder clearClusterDef()

 Optional list of all workers to use in this session.
 

.tensorflow.ClusterDef cluster_def = 14;

getClusterDefBuilder

public ClusterDef.Builder getClusterDefBuilder()

 Optional list of all workers to use in this session.
 

.tensorflow.ClusterDef cluster_def = 14;

getClusterDefOrBuilder

public ClusterDefOrBuilder getClusterDefOrBuilder()

 Optional list of all workers to use in this session.
 

.tensorflow.ClusterDef cluster_def = 14;

Specified by:

getClusterDefOrBuilder in interface ConfigProtoOrBuilder

getIsolateSessionState

public boolean getIsolateSessionState()

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

bool isolate_session_state = 15;

Specified by:

getIsolateSessionState in interface ConfigProtoOrBuilder

setIsolateSessionState

public ConfigProto.Builder setIsolateSessionState(boolean value)

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

bool isolate_session_state = 15;

clearIsolateSessionState

public ConfigProto.Builder clearIsolateSessionState()

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

bool isolate_session_state = 15;

hasExperimental

public boolean hasExperimental()

.tensorflow.ConfigProto.Experimental experimental = 16;

Specified by:

hasExperimental in interface ConfigProtoOrBuilder

getExperimental

public ConfigProto.Experimental getExperimental()

.tensorflow.ConfigProto.Experimental experimental = 16;

Specified by:

getExperimental in interface ConfigProtoOrBuilder

setExperimental

public ConfigProto.Builder setExperimental(ConfigProto.Experimental value)

.tensorflow.ConfigProto.Experimental experimental = 16;

setExperimental

public ConfigProto.Builder setExperimental(ConfigProto.Experimental.Builder builderForValue)

.tensorflow.ConfigProto.Experimental experimental = 16;

mergeExperimental

public ConfigProto.Builder mergeExperimental(ConfigProto.Experimental value)

.tensorflow.ConfigProto.Experimental experimental = 16;

clearExperimental

public ConfigProto.Builder clearExperimental()

.tensorflow.ConfigProto.Experimental experimental = 16;

getExperimentalBuilder

public ConfigProto.Experimental.Builder getExperimentalBuilder()

.tensorflow.ConfigProto.Experimental experimental = 16;

getExperimentalOrBuilder

public ConfigProto.ExperimentalOrBuilder getExperimentalOrBuilder()

.tensorflow.ConfigProto.Experimental experimental = 16;

Specified by:

getExperimentalOrBuilder in interface ConfigProtoOrBuilder

setUnknownFields

public final ConfigProto.Builder setUnknownFields(org.nd4j.shade.protobuf.UnknownFieldSet unknownFields)

Specified by:

setUnknownFields in interface org.nd4j.shade.protobuf.Message.Builder

Overrides:

setUnknownFields in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>

mergeUnknownFields

public final ConfigProto.Builder mergeUnknownFields(org.nd4j.shade.protobuf.UnknownFieldSet unknownFields)

Specified by:

mergeUnknownFields in interface org.nd4j.shade.protobuf.Message.Builder

Overrides:

mergeUnknownFields in class org.nd4j.shade.protobuf.GeneratedMessageV3.Builder<ConfigProto.Builder>