Aufbau von AI-Anwendungen mit Java und Gradle

Künstliche Intelligenz (KI) verändert verschiedene Branchen und ändert die Art und Weise, wie Unternehmen arbeiten. Obwohl Python oft als bevorzugte Sprache für die KI-Entwicklung angesehen wird, bietet Java robuste Bibliotheken und Frameworks, die es zu einer ebenso starken Konkurrentin für die Erstellung von anwendungen basierend auf KI machen. In diesem Artikel erkunden wir die Verwendung von Java und Gradle für die KI-Entwicklung, indem wir beliebte Bibliotheken diskutieren, Codebeispiele liefern und funktionierende Beispiele vom Anfang bis zum Ende demonstrieren.

Java-Bibliotheken für die KI-Entwicklung

Java bietet mehrere leistungsstarke Bibliotheken und Frameworks für den Aufbau von KI-Anwendungen, einschließlich:

• Deeplearning4j (DL4J) – Eine Deep-Learning-Bibliothek für Java, die eine Plattform für den Aufbau, das Training und die Bereitstellung von neuronalen Netzwerken bietet. DL4J unterstützt verschiedene neuronale Netzwerkarchitekturen und bietet GPU-Beschleunigung für schnellere Berechnungen.
• Weka – Eine Sammlung von maschinellem Lernen für datenanalyseaufgaben, Weka bietet Werkzeuge für Datenvorverarbeitung, Klassifizierung, Regression, Clusteranalyse und Visualisierung.
• Encog – Ein maschinelles Lernframework, das verschiedene fortgeschrittene Algorithmen unterstützt, einschließlich neuronaler Netzwerke, Support-Vektor-Maschinen, genetischer Programmierung und Bayes’scher Netzwerke

Abhängigkeiten mit Gradle einrichten

Um die AI-Entwicklung in Java mit Gradle zu beginnen, richten Sie die erforderlichen Abhängigkeiten in Ihrem Projekt ein, indem Sie die folgenden Zeilen in Ihrer Datei build.gradle hinzufügen:

dependencies {

    implementation 'org.deeplearning4j:deeplearning4j-core:1.0.0-M1.1'
    implementation 'nz.ac.waikato.cms.weka:weka-stable:3.8.5'
    implementation 'org.encog:encog-core:3.4'
}

Code-Beispiele

Erstellen eines einfachen neuronalen Netzwerks mit DL4J

Dieses Beispiel zeigt, wie man ein grundlegendes neurales Netzwerk mithilfe der Deeplearning4j (DL4J) Bibliothek erstellt. Der Code legt ein zweischichtiges neuronales Netzwerk-Architektur fest, bestehend aus einer DenseLayer mit 4 Eingabeneuronen und 10 Ausgabeneuronen, die die ReLU-Aktivierungsfunktion verwendet, und einer OutputLayer mit 10 Eingabeneuronen und 3 Ausgabeneuronen, die die Softmax-Aktivierungsfunktion und die Negative Log-Likelihood als Verlustfunktion verwendet. Das Modell wird dann initialisiert und kann weiter auf Daten trainiert und für Vorhersagen verwendet werden.

import org.deeplearning4j.nn.api.OptimizationAlgorithm;
import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
import org.deeplearning4j.nn.conf.layers.DenseLayer;
import org.deeplearning4j.nn.conf.layers.OutputLayer;
import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
import org.deeplearning4j.nn.weights.WeightInit;
import org.nd4j.linalg.activations.Activation;
import org.nd4j.linalg.learning.config.Sgd;
import org.nd4j.linalg.lossfunctions.LossFunctions;

public class SimpleNeuralNetwork {

    public static void main(String[] args) {

        MultiLayerConfiguration conf = new NeuralNetConfiguration.Builder()
                .seed(123)
                .optimizationAlgo(OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT)
                .updater(new Sgd(0.01))
                .list()
                .layer(0, new DenseLayer.Builder().nIn(4).nOut(10)
                        .weightInit(WeightInit.XAVIER)
                        .activation(Activation.RELU)
                        .build())
                .layer(1, new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
                        .nIn(10).nOut(3)
                        .weightInit(WeightInit.XAVIER)
                        .activation(Activation.SOFTMAX)
                        .build())
                .pretrain(false).backprop(true)
                .build();

        MultiLayerNetwork model = new MultiLayerNetwork(conf);

        model.init();
    }
}

Klassifizierung mit Weka

Dieses Beispiel zeigt, wie man die Weka-Bibliothek zur Klassifizierung im Iris-Datensatz verwendet. Der Code lädt den Datensatz aus einer ARFF-Datei, setzt die Klassenattribute (das Attribut, das wir vorhersagen möchten) als letztes Attribut im Datensatz, erstellt einen Naive Bayes Klassifikator unter Verwendung der geladenen Daten und klassifiziert eine neue Instanz.

import weka.classifiers.bayes.NaiveBayes;
import weka.core.Instance;
import weka.core.Instances;
import weka.core.converters.ConverterUtils.DataSource;

public class WekaClassification {

    public static void main(String[] args) throws Exception {

        DataSource source = new DataSource("data/iris.arff");

        Instances data = source.getDataSet();
        data.setClassIndex(data.numAttributes() - 1);

        NaiveBayes nb = new NaiveBayes();
        nb.buildClassifier(data);

        Instance newInstance = data.instance(0);
        double result = nb.classifyInstance(newInstance);
        System.out.println("Predicted class: " + data.classAttribute().value((int) result));
    }
}

Schlussfolgerung

Java, mit seinem reichen Ökosystem von Bibliotheken und Frameworks für die AI-Entwicklung, ist eine geeignete Wahl für den Aufbau von AI-basierten Anwendungen. Indem man beliebte Bibliotheken wie Deeplearning4j, Weka und Encog nutzt und Gradle als Build-Tool verwendet, können Entwickler leistungsstarke AI-Lösungen mit der vertrauten Java-Programmiersprache erstellen.

Die bereitgestellten Codebeispiele zeigen die Einfachheit der Einrichtung und Konfiguration von AI-Anwendungen mit Java und Gradle. Das DL4J-Beispiel zeigt, wie man ein einfaches Deep-Learning-Modell erstellt, das für Aufgaben wie Bilderkennung oder natürliche Sprachverarbeitung angewendet werden kann. Das Weka-Beispiel demonstriert, wie man Java und die Weka-Bibliothek für maschinelles Lernen verwendet, insbesondere für Klassifizierungsaufgaben, die für die Implementierung von maschinellem Lernen in Java-Anwendungen von großem Wert sind, wie z.B. die Vorhersage von Kundenabwanderung oder die Klassifizierung von E-Mails als Spam oder Nicht-Spam.

Happy Learning!!