Questa pagina è stata tradotta dall'API Cloud Translation.

Installa TensorFlow Java

TensorFlow Java può essere eseguito su qualsiasi JVM per creare, addestrare e distribuire modelli di machine learning. Supporta l'esecuzione sia della CPU che della GPU, in modalità grafico o entusiasta, e presenta una ricca API per l'utilizzo di TensorFlow in un ambiente JVM. Java e altri linguaggi JVM, come Scala e Kotlin, sono spesso utilizzati in aziende grandi e piccole in tutto il mondo, il che rende TensorFlow Java una scelta strategica per l'adozione del machine learning su larga scala.

Requisiti

TensorFlow Java funziona su Java 8 e versioni successive e supporta immediatamente le seguenti piattaforme:

Ubuntu 16.04 o successiva; 64 bit, x86
macOS 10.12.6 (Sierra) o versione successiva; 64 bit, x86
Windows 7 o successivo; 64 bit, x86

Versioni

TensorFlow Java ha un proprio ciclo di rilascio, indipendente dal runtime TensorFlow . Di conseguenza, la sua versione non corrisponde alla versione del runtime TensorFlow su cui viene eseguito. Consulta la tabella delle versioni Java di TensorFlow per elencare tutte le versioni disponibili e la relativa mappatura con il runtime TensorFlow.

Artefatti

Esistono diversi modi per aggiungere TensorFlow Java al tuo progetto. Il modo più semplice è aggiungere una dipendenza all'artefatto tensorflow-core-platform , che include sia l'API TensorFlow Java Core che le dipendenze native necessarie per l'esecuzione su tutte le piattaforme supportate.

Puoi anche selezionare una delle seguenti estensioni invece della versione pura della CPU:

tensorflow-core-platform-mkl : supporto per Intel® MKL-DNN su tutte le piattaforme
tensorflow-core-platform-gpu : supporto per CUDA® su piattaforme Linux e Windows
tensorflow-core-platform-mkl-gpu : supporto per Intel® MKL-DNN e CUDA® su piattaforma Linux.

Inoltre, è possibile aggiungere una dipendenza separata dalla libreria tensorflow-framework per beneficiare di un ricco set di utilità per l'apprendimento automatico basato su TensorFlow sulla JVM.

Installazione con Maven

Per includere TensorFlow nella tua applicazione Maven , aggiungi una dipendenza dai suoi artefatti al file pom.xml del tuo progetto. Per esempio,

<dependency>
  <groupId>org.tensorflow</groupId>
  <artifactId>tensorflow-core-platform</artifactId>
  <version>0.3.3</version>
</dependency>

Ridurre il numero di dipendenze

È importante notare che l'aggiunta di una dipendenza su un artefatto tensorflow-core-platform importerà le librerie native per tutte le piattaforme supportate, il che può aumentare significativamente le dimensioni del tuo progetto.

Se desideri scegliere come target un sottoinsieme delle piattaforme disponibili, puoi escludere gli artefatti non necessari dalle altre piattaforme utilizzando la funzione di esclusione delle dipendenze di Maven .

Un altro modo per selezionare quali piattaforme desideri includere nella tua applicazione è impostare le proprietà del sistema JavaCPP, nella riga di comando di Maven o nel tuo pom.xml . Per ulteriori dettagli consultare la documentazione JavaCPP.

Utilizzo delle istantanee

Gli ultimi snapshot di sviluppo Java di TensorFlow dal repository di sorgenti Java di TensorFlow sono disponibili nel repository OSS Sonatype Nexus. Per dipendere da questi artefatti, assicurati di configurare il repository di snapshot OSS nel tuo pom.xml .

<repositories>
    <repository>
        <id>tensorflow-snapshots</id>
        <url>https://oss.sonatype.org/content/repositories/snapshots/</url>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

<dependencies>
    <dependency>
        <groupId>org.tensorflow</groupId>
        <artifactId>tensorflow-core-platform</artifactId>
        <version>0.4.0-SNAPSHOT</version>
    </dependency>
</dependencies>

Installazione con Gradle

Per includere TensorFlow nella tua applicazione Gradle , aggiungi una dipendenza dai suoi artefatti al file build.gradle del tuo progetto. Per esempio,

repositories {
    mavenCentral()
}

dependencies {
    compile group: 'org.tensorflow', name: 'tensorflow-core-platform', version: '0.3.3'
}

Ridurre il numero di dipendenze

Escludere gli artefatti nativi da TensorFlow Java con Gradle non è così facile come con Maven. Ti consigliamo di utilizzare i plugin Gradle JavaCPP per ridurre questo numero di dipendenze.

Si prega di leggere la documentazione di Gradle JavaCPP per maggiori dettagli.

Installazione da sorgenti

Per creare TensorFlow Java dai sorgenti ed eventualmente personalizzarlo, leggere le seguenti istruzioni .

Programma di esempio

Questo esempio mostra come creare un progetto Apache Maven con TensorFlow. Innanzitutto, aggiungi la dipendenza TensorFlow al file pom.xml del progetto:

<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.myorg</groupId>
    <artifactId>hellotensorflow</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <exec.mainClass>HelloTensorFlow</exec.mainClass>
        <!-- Minimal version for compiling TensorFlow Java is JDK 8 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <!-- Include TensorFlow (pure CPU only) for all supported platforms -->
        <dependency>
            <groupId>org.tensorflow</groupId>
            <artifactId>tensorflow-core-platform</artifactId>
            <version>0.3.3</version>
        </dependency>
    </dependencies>
</project>

Crea il file sorgente src/main/java/HelloTensorFlow.java :

import org.tensorflow.ConcreteFunction;
import org.tensorflow.Signature;
import org.tensorflow.Tensor;
import org.tensorflow.TensorFlow;
import org.tensorflow.op.Ops;
import org.tensorflow.op.core.Placeholder;
import org.tensorflow.op.math.Add;
import org.tensorflow.types.TInt32;

public class HelloTensorFlow {

  public static void main(String[] args) throws Exception {
    System.out.println("Hello TensorFlow " + TensorFlow.version());

    try (ConcreteFunction dbl = ConcreteFunction.create(HelloTensorFlow::dbl);
        TInt32 x = TInt32.scalarOf(10);
        Tensor dblX = dbl.call(x)) {
      System.out.println(x.getInt() + " doubled is " + ((TInt32)dblX).getInt());
    }
  }

  private static Signature dbl(Ops tf) {
    Placeholder<TInt32> x = tf.placeholder(TInt32.class);
    Add<TInt32> dblX = tf.math.add(x, x);
    return Signature.builder().input("x", x).output("dbl", dblX).build();
  }
}

Compila ed esegui:

mvn -q compile exec:java

Il comando stampa la versione di TensorFlow e un semplice calcolo.

Successo! TensorFlow Java è configurato.