Un grafico che può essere richiamato come una singola funzione, con una firma di input e output.
Una funzione può anche richiamare una tf.function definita in un SavedModelBundle .
ConcreteFunction myFunction = savedModelBundle.function("myFunctionSignatureName");
Map<String, Tensor> outputTensorMap = myFunction.call(inputTensorMap);
Metodi pubblici
| Tensore | |
| Mappa<Stringa, Tensore > | |
| vuoto | vicino () |
| Funzione statica Concrete | creare ( Firma firma , Sessione sessione) Crea una funzione da una firma e una sessione grafica valida. |
| Funzione statica Concrete | |
| Funzione statica Concrete | |
| Grafico | grafico () Restituisce il grafico di questa funzione |
| vuoto | salva (Stringa exportDir) Esporta questa funzione come modello salvato. |
| Sessione | |
| Firma | firma () Restituisce la firma di questa funzione |
| Corda | aStringa () |
Metodi ereditati
Metodi pubblici
chiamata tensore pubblica ( tensore tensore)
Richiama una funzione con un singolo input e output.
Il chiamante è responsabile della chiusura di tutti i tensori.
Parametri
| tensore | tensore di ingresso |
|---|
Ritorni
- tensore di uscita
Lancia
| IllegalArgumentException | se nella funzione sono definiti più parametri di input o output |
|---|
chiamata pubblica Map<String, Tensor > (argomenti Map<String, Tensor >)
Richiama una funzione.
Il chiamante è responsabile della chiusura di tutti i tensori.
Parametri
| argomenti | elenco di tensori da passare in input alla funzione, mappati in base al nome della firma |
|---|
Ritorni
- tensori di output risultanti dall'esecuzione della funzione, mappati in base al nome della firma
Lancia
| IllegalArgumentException |
|---|
pubblico vuoto chiudi ()
creazione di ConcreteFunction statica pubblica (firma della firma , sessione della sessione )
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
}
}Parametri
| firma | firma della funzione da creare |
|---|---|
| sessione | una sessione valida a un grafico inizializzato |
Ritorni
- una nuova funzione
creazione di ConcreteFunction statica pubblica (Funzione<Ops, Firma > functionBuilder)
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());
}
}
}
}Parametri
| functionBuilder | costruttore di funzioni |
|---|
Ritorni
- la nuova funzione
creazione di ConcreteFunction statica pubblica (firma della firma , grafico del grafico )
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
}
}Parametri
| firma | firma della funzione da creare |
|---|---|
| grafico | un grafico valido e inizializzato |
Ritorni
- una nuova funzione
salvataggio vuoto pubblico (Stringa exportDir)
Esporta questa funzione come modello salvato.
Questo metodo è una comoda scorciatoia equivalente a SavedModel.exporter(exportDir).withFunction(this).export()
Parametri
| diresportazione | directory in cui esportare il modello salvato |
|---|
Lancia
| IOException | se il modello salvato o lo stato della variabile non possono essere scritti su disco |
|---|
sessione pubblica ()
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.
Ritorni
- la sessione della funzione