Installa TensorFlow Java

Tensorflow Java può funzionare su qualsiasi JVM per la costruzione, la formazione e l'implementazione di modelli di apprendimento automatico. Supporta l'esecuzione sia della CPU che della GPU, in modalità grafico o desideroso, 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 grandi e piccole imprese 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 versioni successive; 64 bit, x86
  • macOS 10.12.6 (Sierra) o versioni successive; 64 bit, x86
  • Windows 7 o versioni successive; 64 bit, x86

Versioni

Tensorflow Java ha il suo ciclo di rilascio, indipendentemente dal tempo di esecuzione tensorflow . Di conseguenza, la sua versione non corrisponde alla versione del runtime di TensorFlow su cui viene eseguito. Consultare il tensorflow Java versioni tavolo per elencare tutte le versioni disponibili e la loro mappatura con il runtime tensorflow.

Artefatti

Ci sono diversi modi per aggiungere tensorflow Java per il progetto. Quella più semplice è quello di aggiungere una dipendenza sul tensorflow-core-platform artefatto, che comprende sia l'API Java tensorflow Core e le dipendenze nativi che richiede per funzionare su tutte le piattaforme supportate.

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

  • 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, una dipendenza separato sul tensorflow-framework libreria può essere aggiunto a beneficiare di una ricca serie di utility per l'apprendimento automatico tensorflow basata sulla JVM.

Installazione con Maven

Per includere nella vostra tensorflow Maven applicazione, aggiungere una dipendenza sui suoi manufatti a del progetto pom.xml file. Per esempio,

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

Ridurre il numero di dipendenze

E 'importante notare che l'aggiunta di una dipendenza da un tensorflow-core-platform artefatto importerà librerie native per tutte le piattaforme supportate, che possono aumentare in modo significativo la dimensione del progetto.

Se si desidera indirizzare un sottoinsieme delle piattaforme disponibili, allora è possibile escludere i manufatti inutili delle altre piattaforme che utilizzano l'Esclusione Maven Dipendenza funzione.

Un altro modo per selezionare quali piattaforme si desidera includere nella vostra applicazione è di proprietà di insieme del sistema JavaCPP, nella riga di comando Maven o nel vostro pom.xml . Si prega di consultare JavaCPP la documentazione per maggiori dettagli.

Utilizzo delle istantanee

Le ultime tensorflow Java istantanee di sviluppo dal repository di origine tensorflow Java sono disponibili sul OSS Sonatype repository Nexus. A dipendere da questi manufatti, assicurarsi di configurare repository OSS istantanee nella vostra 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 nella vostra tensorflow Gradle applicazione, aggiungere una dipendenza sui suoi manufatti a del progetto build.gradle file. 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 è facile come con Maven. Ti consigliamo di utilizzare i plugin Gradle JavaCPP per ridurre questo numero di dipendenze.

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

Installazione da sorgenti

Per costruire tensorflow Java da fonti, ed eventualmente personalizzarlo, si prega di leggere le seguenti istruzioni .

Programma di esempio

Questo esempio mostra come creare un progetto Apache Maven con TensorFlow. In primo luogo, aggiungere la dipendenza tensorflow al progetto pom.xml di file:

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

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