ConcreteFunction

Richiama una funzione con un singolo input e output.

Il chiamante è responsabile della chiusura di tutti i tensori.

Richiama una funzione.

Il chiamante è responsabile della chiusura di tutti i tensori.

Crea una funzione da una firma e una sessione grafica valida.

La funzione non sarà proprietaria della sessione né del relativo grafico, il che significa che la loro durata può estendersi oltre l'ambito della funzione. Pertanto non è necessario chiudere la funzione dopo l'utilizzo. Per esempio:

try (Graph g = new Graph()) {
   Placeholder<TFloat32> input = tf.placeholder(TFloat32.class);
   Add<TFloat32> output = tf.math.add(input, tf.constant(2.0f));
   Signature signature = Signature.builder().input("x", input).output("y", output).build();

   try (Session s = new Session(g)) {
     // Auto-closing the function just as an example but this is not required since it has
     // no effect
     try (ConcreteFunction f = ConcreteFunction.create(signature, s);
         TFloat32 t = TFloat32.scalarOf(2.0f)) {
       assertEquals(4.0f, ((TFloat32)function.call(x)).getFloat());
     
     // Session s is still valid at this point
   }
   // Graph g is still valid at this point
 }
 }

Crea una funzione costruendo un nuovo grafico.

Il functionBuilder deve inizializzare il grafico della funzione dall'istanza ERROR(/Ops) fornita e restituire una firma valida che verrà utilizzata per alimentare i tensori di input e recuperare i tensori di output durante l'esecuzione.

La funzione sarà proprietaria del nuovo grafico e della sessione risultante. Pertanto, la funzione deve essere racchiusa correttamente in un blocco try-with-resources per garantire che tutte le risorse native verranno liberate una volta eliminata la funzione. Per esempio:

public class MyModel {

   public static Signature addTwo(Ops tf) {
     Placeholder<TFloat32> input = tf.placeholder(TFloat32.class);
     Add<TFloat32> output = tf.math.add(input, tf.constant(2.0f));
     return Signature.builder("addTwo").input("x", input).output("y", output).build();
   

   public static void main(String args[]) {
     try (ConcreteFunction function = ConcreteFunction.create(MyModel::addTwo);
         TFloat32 x = TFloat32.scalarOf(2.0f)) {
       assertEquals(4.0f, ((TFloat32)function.call(x)).getFloat());
     }
   }
 }
 }

Crea una funzione da una firma e un grafico esistente.

La funzione manterrà la proprietà della sessione utilizzata per eseguire il grafico ma non del grafico stesso, il che significa che la durata di quest'ultimo può estendersi oltre l'ambito della funzione. Per esempio:

try (Graph g = new Graph()) {
   Placeholder<TFloat32> input = tf.placeholder(TFloat32.class);
   Add<TFloat32> output = tf.math.add(input, tf.constant(2.0f));
   Signature signature = Signature.builder().input("x", input).output("y", output).build();

   try (ConcreteFunction f = ConcreteFunction.create(signature, g);
       TFloat32 x = TFloat32.scalarOf(2.0f)) {
     assertEquals(4.0f, ((TFloat32)function.call(x)).getFloat());
   
   // Graph g is still valid at this point
 }
 }

Restituisce il grafico di questa funzione

Esporta questa funzione come modello salvato.

Questo metodo è una comoda scorciatoia equivalente a SavedModel.exporter(exportDir).withFunction(this).export()

Restituisce la sessione utilizzata per eseguire il grafico quando si chiama questa funzione

In generale, un utente non ha bisogno di gestire direttamente la sessione di una funzione e di affidarsi invece a call(Map) per eseguire il grafico. Ma in alcuni casi potrebbe essere necessario l'accesso diretto alla sessione, poiché consente più opzioni di esecuzione.

Restituisce la firma di questa funzione