CallableOptions

כיתה אחרונה ציבורית CallableOptions

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

כיתות מקוננות

מַחלָקָה CallableOptions.Builder 
 Defines a subgraph in another `GraphDef` as a set of feed points and nodes
 to be fetched or executed. 

קבועים

int FEED_DEVICES_FIELD_NUMBER
int FEED_FIELD_NUMBER
int FETCH_DEVICES_FIELD_NUMBER
int FETCH_FIELD_NUMBER
int FETCH_SKIP_SYNC_FIELD_NUMBER
int RUN_OPTIONS_FIELD_NUMBER
int TARGET_FIELD_NUMBER
int TENSOR_CONNECTION_FIELD_NUMBER

שיטות ציבוריות

בוליאני
containsFeedDevices (מפתח מחרוזת) 
 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
בוליאני
containsFetchDevices (מפתח מחרוזת)
map<string, string> fetch_devices = 7;
בוליאני
שווה (Object obj)
סטטי CallableOptions
getDefaultInstance ()
CallableOptions
getDefaultInstanceForType ()
final static com.google.protobuf.Descriptors.Descriptor
getDescriptor ()
חוּט
getFeed (int index) 
 Tensors to be fed in the callable.
com.google.protobuf.ByteString
getFeedBytes (int index) 
 Tensors to be fed in the callable.
int
getFeedCount () 
 Tensors to be fed in the callable.
מפה<String, String>
getFeedDevices ()
השתמש ב- getFeedDevicesMap() במקום זאת.
int
getFeedDevicesCount () 
 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
מפה<String, String>
getFeedDevicesMap () 
 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
חוּט
getFeedDevicesOrDefault (מפתח מחרוזת, מחרוזת defaultValue) 
 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
חוּט
getFeedDevicesOrThrow (מפתח מחרוזת) 
 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
com.google.protobuf.ProtocolStringList
getFeedList () 
 Tensors to be fed in the callable.
חוּט
getFetch (int index) 
 Fetches.
com.google.protobuf.ByteString
getFetchBytes (int index) 
 Fetches.
int
getFetchCount () 
 Fetches.
מפה<String, String>
getFetchDevices ()
השתמש ב- getFetchDevicesMap() במקום זאת.
int
getFetchDevicesCount ()
map<string, string> fetch_devices = 7;
מפה<String, String>
getFetchDevicesMap ()
map<string, string> fetch_devices = 7;
חוּט
getFetchDevicesOrDefault (מפתח מחרוזת, מחרוזת defaultValue)
map<string, string> fetch_devices = 7;
חוּט
getFetchDevicesOrThrow (מפתח מחרוזת)
map<string, string> fetch_devices = 7;
com.google.protobuf.ProtocolStringList
getFetchList () 
 Fetches.
בוליאני
getFetchSkipSync () 
 By default, RunCallable() will synchronize the GPU stream before returning
 fetched tensors on a GPU device, to ensure that the values in those tensors
 have been produced.
getParserForType ()
RunOptions
getRunOptions () 
 Options that will be applied to each run.
RunOptionsOrBuilder
getRunOptionsOrBuilder () 
 Options that will be applied to each run.
int
getSerializedSize ()
חוּט
getTarget (int index) 
 Target Nodes.
com.google.protobuf.ByteString
getTargetBytes (int index) 
 Target Nodes.
int
getTargetCount () 
 Target Nodes.
com.google.protobuf.ProtocolStringList
getTargetList () 
 Target Nodes.
TensorConnection
getTensorConnection (int index) 
 Tensors to be connected in the callable.
int
getTensorConnectionCount () 
 Tensors to be connected in the callable.
רשימה< TensorConnection >
getTensorConnectionList () 
 Tensors to be connected in the callable.
TensorConnectionOrBuilder
getTensorConnectionOrBuilder (int index) 
 Tensors to be connected in the callable.
רשימה<? מרחיב את TensorConnectionOrBuilder >
getTensorConnectionOrBuilderList () 
 Tensors to be connected in the callable.
final com.google.protobuf.UnknownFieldSet
getUnknownFields ()
בוליאני
hasRunOptions () 
 Options that will be applied to each run.
int
hashcode ()
בוליאנית סופית
isinitialized ()
סטטי CallableOptions.Builder
newBuilder ()
סטטי CallableOptions.Builder
newBuilder (אב-טיפוס CallableOptions )
CallableOptions.Builder
newBuilderForType ()
סטטי CallableOptions
parseDelimitedFrom (קלט InputStream)
סטטי CallableOptions
parseDelimitedFrom (קלט InputStream, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
סטטי CallableOptions
parseFrom (נתוני ByteBuffer, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
סטטי CallableOptions
parseFrom (קלט com.google.protobuf.CodedInputStream)
סטטי CallableOptions
parseFrom (נתוני byte[], com.google.protobuf.ExtensionRegistryLite extensionRegistry)
סטטי CallableOptions
parseFrom (נתוני ByteBuffer)
סטטי CallableOptions
parseFrom (קלט com.google.protobuf.CodedInputStream, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
סטטי CallableOptions
parseFrom (נתוני com.google.protobuf.ByteString)
סטטי CallableOptions
parseFrom (קלט InputStream, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
סטטי CallableOptions
parseFrom (נתוני com.google.protobuf.ByteString, com.google.protobuf.ExtensionRegistryLite extensionRegistry)
סטָטִי
מנתח ()
CallableOptions.Builder
toBuilder ()
בָּטֵל
writeTo (פלט com.google.protobuf.CodedOutputStream)

שיטות בירושה

קבועים

אינט סופי סטטי ציבורי FEED_DEVICES_FIELD_NUMBER

ערך קבוע: 6

גמר סטטי ציבורי FEED_FIELD_NUMBER

ערך קבוע: 1

גמר סטטי ציבורי FETCH_DEVICES_FIELD_NUMBER

ערך קבוע: 7

גמר סטטי ציבורי FETCH_FIELD_NUMBER

ערך קבוע: 2

גמר סטטי ציבורי FETCH_SKIP_SYNC_FIELD_NUMBER

ערך קבוע: 8

גמר סטטי ציבורי RUN_OPTIONS_FIELD_NUMBER

ערך קבוע: 4

גמר סטטי ציבורי TARGET_FIELD_NUMBER

ערך קבוע: 3

גמר סטטי ציבורי TENSOR_CONNECTION_FIELD_NUMBER

ערך קבוע: 5

שיטות ציבוריות

Public Boolean containsFeedDevices (מפתח מחרוזת) 

 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
 The options below allow changing that - feeding tensors backed by
 device memory, or returning tensors that are backed by device memory.
 The maps below map the name of a feed/fetch tensor (which appears in
 'feed' or 'fetch' fields above), to the fully qualified name of the device
 owning the memory backing the contents of the tensor.
 For example, creating a callable with the following options:
 CallableOptions {
   feed: "a:0"
   feed: "b:0"
   fetch: "x:0"
   fetch: "y:0"
   feed_devices: {
     "a:0": "/job:localhost/replica:0/task:0/device:GPU:0"
   }
   fetch_devices: {
     "y:0": "/job:localhost/replica:0/task:0/device:GPU:0"
  }
 }
 means that the Callable expects:
 - The first argument ("a:0") is a Tensor backed by GPU memory.
 - The second argument ("b:0") is a Tensor backed by host memory.
 and of its return values:
 - The first output ("x:0") will be backed by host memory.
 - The second output ("y:0") will be backed by GPU memory.
 FEEDS:
 It is the responsibility of the caller to ensure that the memory of the fed
 tensors will be correctly initialized and synchronized before it is
 accessed by operations executed during the call to Session::RunCallable().
 This is typically ensured by using the TensorFlow memory allocators
 (Device::GetAllocator()) to create the Tensor to be fed.
 Alternatively, for CUDA-enabled GPU devices, this typically means that the
 operation that produced the contents of the tensor has completed, i.e., the
 CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or
 cuStreamSynchronize()).
map<string, string> feed_devices = 6;

Public Boolean containsFetchDevices (מפתח מחרוזת)

map<string, string> fetch_devices = 7;

שווה ערך בוליאני ציבורי (Object obj)

Public static CallableOptions getDefaultInstance ()

public CallableOptions getDefaultInstanceForType ()

public static final com.google.protobuf.Descriptors.Descriptor getDescriptor ()

getFeed של מחרוזת ציבורית (int index) 

 Tensors to be fed in the callable. Each feed is the name of a tensor.
repeated string feed = 1;

public com.google.protobuf.ByteString getFeedBytes (int index) 

 Tensors to be fed in the callable. Each feed is the name of a tensor.
repeated string feed = 1;

public int getFeedCount () 

 Tensors to be fed in the callable. Each feed is the name of a tensor.
repeated string feed = 1;

מפה ציבורית<String, String> getFeedDevices ()

השתמש ב- getFeedDevicesMap() במקום זאת.

public int getFeedDevicesCount () 

 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
 The options below allow changing that - feeding tensors backed by
 device memory, or returning tensors that are backed by device memory.
 The maps below map the name of a feed/fetch tensor (which appears in
 'feed' or 'fetch' fields above), to the fully qualified name of the device
 owning the memory backing the contents of the tensor.
 For example, creating a callable with the following options:
 CallableOptions {
   feed: "a:0"
   feed: "b:0"
   fetch: "x:0"
   fetch: "y:0"
   feed_devices: {
     "a:0": "/job:localhost/replica:0/task:0/device:GPU:0"
   }
   fetch_devices: {
     "y:0": "/job:localhost/replica:0/task:0/device:GPU:0"
  }
 }
 means that the Callable expects:
 - The first argument ("a:0") is a Tensor backed by GPU memory.
 - The second argument ("b:0") is a Tensor backed by host memory.
 and of its return values:
 - The first output ("x:0") will be backed by host memory.
 - The second output ("y:0") will be backed by GPU memory.
 FEEDS:
 It is the responsibility of the caller to ensure that the memory of the fed
 tensors will be correctly initialized and synchronized before it is
 accessed by operations executed during the call to Session::RunCallable().
 This is typically ensured by using the TensorFlow memory allocators
 (Device::GetAllocator()) to create the Tensor to be fed.
 Alternatively, for CUDA-enabled GPU devices, this typically means that the
 operation that produced the contents of the tensor has completed, i.e., the
 CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or
 cuStreamSynchronize()).
map<string, string> feed_devices = 6;

מפה ציבורית<String, String> getFeedDevicesMap () 

 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
 The options below allow changing that - feeding tensors backed by
 device memory, or returning tensors that are backed by device memory.
 The maps below map the name of a feed/fetch tensor (which appears in
 'feed' or 'fetch' fields above), to the fully qualified name of the device
 owning the memory backing the contents of the tensor.
 For example, creating a callable with the following options:
 CallableOptions {
   feed: "a:0"
   feed: "b:0"
   fetch: "x:0"
   fetch: "y:0"
   feed_devices: {
     "a:0": "/job:localhost/replica:0/task:0/device:GPU:0"
   }
   fetch_devices: {
     "y:0": "/job:localhost/replica:0/task:0/device:GPU:0"
  }
 }
 means that the Callable expects:
 - The first argument ("a:0") is a Tensor backed by GPU memory.
 - The second argument ("b:0") is a Tensor backed by host memory.
 and of its return values:
 - The first output ("x:0") will be backed by host memory.
 - The second output ("y:0") will be backed by GPU memory.
 FEEDS:
 It is the responsibility of the caller to ensure that the memory of the fed
 tensors will be correctly initialized and synchronized before it is
 accessed by operations executed during the call to Session::RunCallable().
 This is typically ensured by using the TensorFlow memory allocators
 (Device::GetAllocator()) to create the Tensor to be fed.
 Alternatively, for CUDA-enabled GPU devices, this typically means that the
 operation that produced the contents of the tensor has completed, i.e., the
 CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or
 cuStreamSynchronize()).
map<string, string> feed_devices = 6;

מחרוזת ציבורית getFeedDevicesOrDefault (מפתח מחרוזת, מחרוזת defaultValue) 

 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
 The options below allow changing that - feeding tensors backed by
 device memory, or returning tensors that are backed by device memory.
 The maps below map the name of a feed/fetch tensor (which appears in
 'feed' or 'fetch' fields above), to the fully qualified name of the device
 owning the memory backing the contents of the tensor.
 For example, creating a callable with the following options:
 CallableOptions {
   feed: "a:0"
   feed: "b:0"
   fetch: "x:0"
   fetch: "y:0"
   feed_devices: {
     "a:0": "/job:localhost/replica:0/task:0/device:GPU:0"
   }
   fetch_devices: {
     "y:0": "/job:localhost/replica:0/task:0/device:GPU:0"
  }
 }
 means that the Callable expects:
 - The first argument ("a:0") is a Tensor backed by GPU memory.
 - The second argument ("b:0") is a Tensor backed by host memory.
 and of its return values:
 - The first output ("x:0") will be backed by host memory.
 - The second output ("y:0") will be backed by GPU memory.
 FEEDS:
 It is the responsibility of the caller to ensure that the memory of the fed
 tensors will be correctly initialized and synchronized before it is
 accessed by operations executed during the call to Session::RunCallable().
 This is typically ensured by using the TensorFlow memory allocators
 (Device::GetAllocator()) to create the Tensor to be fed.
 Alternatively, for CUDA-enabled GPU devices, this typically means that the
 operation that produced the contents of the tensor has completed, i.e., the
 CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or
 cuStreamSynchronize()).
map<string, string> feed_devices = 6;

מחרוזת ציבורית getFeedDevicesOrThrow (מפתח מחרוזת) 

 The Tensor objects fed in the callable and fetched from the callable
 are expected to be backed by host (CPU) memory by default.
 The options below allow changing that - feeding tensors backed by
 device memory, or returning tensors that are backed by device memory.
 The maps below map the name of a feed/fetch tensor (which appears in
 'feed' or 'fetch' fields above), to the fully qualified name of the device
 owning the memory backing the contents of the tensor.
 For example, creating a callable with the following options:
 CallableOptions {
   feed: "a:0"
   feed: "b:0"
   fetch: "x:0"
   fetch: "y:0"
   feed_devices: {
     "a:0": "/job:localhost/replica:0/task:0/device:GPU:0"
   }
   fetch_devices: {
     "y:0": "/job:localhost/replica:0/task:0/device:GPU:0"
  }
 }
 means that the Callable expects:
 - The first argument ("a:0") is a Tensor backed by GPU memory.
 - The second argument ("b:0") is a Tensor backed by host memory.
 and of its return values:
 - The first output ("x:0") will be backed by host memory.
 - The second output ("y:0") will be backed by GPU memory.
 FEEDS:
 It is the responsibility of the caller to ensure that the memory of the fed
 tensors will be correctly initialized and synchronized before it is
 accessed by operations executed during the call to Session::RunCallable().
 This is typically ensured by using the TensorFlow memory allocators
 (Device::GetAllocator()) to create the Tensor to be fed.
 Alternatively, for CUDA-enabled GPU devices, this typically means that the
 operation that produced the contents of the tensor has completed, i.e., the
 CUDA stream has been synchronized (e.g., via cuCtxSynchronize() or
 cuStreamSynchronize()).
map<string, string> feed_devices = 6;

public com.google.protobuf.ProtocolStringList getFeedList () 

 Tensors to be fed in the callable. Each feed is the name of a tensor.
repeated string feed = 1;

מחרוזת ציבורית getFetch (אינדקס אינט) 

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

public com.google.protobuf.ByteString getFetchBytes (int index) 

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

public int getFetchCount () 

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

מפה ציבורית<String, String> getFetchDevices ()

השתמש ב- getFetchDevicesMap() במקום זאת.

public int getFetchDevicesCount ()

map<string, string> fetch_devices = 7;

מפה ציבורית<String, String> getFetchDevicesMap ()

map<string, string> fetch_devices = 7;

מחרוזת ציבורית getFetchDevicesOrDefault (מפתח מחרוזת, מחרוזת defaultValue)

map<string, string> fetch_devices = 7;

מחרוזת ציבורית getFetchDevicesOrThrow (מפתח מחרוזת)

map<string, string> fetch_devices = 7;

public com.google.protobuf.ProtocolStringList getFetchList () 

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

getFetchSkipSync בוליאני ציבורי () 

 By default, RunCallable() will synchronize the GPU stream before returning
 fetched tensors on a GPU device, to ensure that the values in those tensors
 have been produced. This simplifies interacting with the tensors, but
 potentially incurs a performance hit.
 If this options is set to true, the caller is responsible for ensuring
 that the values in the fetched tensors have been produced before they are
 used. The caller can do this by invoking `Device::Sync()` on the underlying
 device(s), or by feeding the tensors back to the same Session using
 `feed_devices` with the same corresponding device name.
bool fetch_skip_sync = 8;

פּוּמְבֵּי getParserForType ()

Public RunOptions getRunOptions () 

 Options that will be applied to each run.
.tensorflow.RunOptions run_options = 4;

public RunOptionsOrBuilder getRunOptionsOrBuilder () 

 Options that will be applied to each run.
.tensorflow.RunOptions run_options = 4;

public int getSerializedSize ()

Public String getTarget (int index) 

 Target Nodes. A list of node names. The named nodes will be run by the
 callable but their outputs will not be returned.
repeated string target = 3;

public com.google.protobuf.ByteString getTargetBytes (int index) 

 Target Nodes. A list of node names. The named nodes will be run by the
 callable but their outputs will not be returned.
repeated string target = 3;

public int getTargetCount () 

 Target Nodes. A list of node names. The named nodes will be run by the
 callable but their outputs will not be returned.
repeated string target = 3;

public com.google.protobuf.ProtocolStringList getTargetList () 

 Target Nodes. A list of node names. The named nodes will be run by the
 callable but their outputs will not be returned.
repeated string target = 3;

TensorConnection ציבורי getTensorConnection (אינדקס אינט) 

 Tensors to be connected in the callable. Each TensorConnection denotes
 a pair of tensors in the graph, between which an edge will be created
 in the callable.
repeated .tensorflow.TensorConnection tensor_connection = 5;

public int getTensorConnectionCount () 

 Tensors to be connected in the callable. Each TensorConnection denotes
 a pair of tensors in the graph, between which an edge will be created
 in the callable.
repeated .tensorflow.TensorConnection tensor_connection = 5;

רשימה ציבורית< TensorConnection > getTensorConnectionList () 

 Tensors to be connected in the callable. Each TensorConnection denotes
 a pair of tensors in the graph, between which an edge will be created
 in the callable.
repeated .tensorflow.TensorConnection tensor_connection = 5;

הציבור TensorConnectionOrBuilder getTensorConnectionOrBuilder (int index) 

 Tensors to be connected in the callable. Each TensorConnection denotes
 a pair of tensors in the graph, between which an edge will be created
 in the callable.
repeated .tensorflow.TensorConnection tensor_connection = 5;

רשימה ציבורית<? מרחיב את TensorConnectionOrBuilder > getTensorConnectionOrBuilderList () 

 Tensors to be connected in the callable. Each TensorConnection denotes
 a pair of tensors in the graph, between which an edge will be created
 in the callable.
repeated .tensorflow.TensorConnection tensor_connection = 5;

public final com.google.protobuf.UnknownFieldSet getUnknownFields ()

בוליאני ציבורי hasRunOptions () 

 Options that will be applied to each run.
.tensorflow.RunOptions run_options = 4;

public int hashCode ()

בוליאני הסופי הציבורי הוא אתחול ()

ציבורי סטטי CallableOptions.Builder newBuilder ()

CallableOptions.Builder newBuilder סטטי ציבורי (אב-טיפוס CallableOptions )

public CallableOptions.Builder newBuilderForType ()

public static CallableOptions parseDelimitedFrom (קלט InputStream)

זורק
IOException

public static CallableOptions parseDelimitedFrom (קלט InputStream, com.google.protobuf.ExtensionRegistryLite extensionRegistry)

זורק
IOException

public static CallableOptions parseFrom (נתוני ByteBuffer, com.google.protobuf.ExtensionRegistryLite extensionRegistry)

זורק
InvalidProtocolBufferException

public static CallableOptions parseFrom (קלט com.google.protobuf.CodedInputStream)

זורק
IOException

public static CallableOptions parseFrom (נתוני byte[], com.google.protobuf.ExtensionRegistryLite extensionRegistry)

זורק
InvalidProtocolBufferException

public static CallableOptions parseFrom (נתוני ByteBuffer)

זורק
InvalidProtocolBufferException

CallableOptions parseFrom סטטי ציבורי (com.google.protobuf.CodedInputStream קלט, com.google.protobuf.ExtensionRegistryLite extensionRegistry)

זורק
IOException

נתוני CallableOptions public static (נתוני com.google.protobuf.ByteString)

זורק
InvalidProtocolBufferException

public static CallableOptions parseFrom (קלט InputStream, com.google.protobuf.ExtensionRegistryLite extensionRegistry)

זורק
IOException

public static CallableOptions parseFrom (נתוני com.google.protobuf.ByteString, com.google.protobuf.ExtensionRegistryLite extensionRegistry)

זורק
InvalidProtocolBufferException

סטטי ציבורי מנתח ()

Public CallableOptions.Builder toBuilder ()

public void writeTo (פלט com.google.protobuf.CodedOutputStream)

זורק
IOException