Bouwen van AI-toepassingen met Java en Gradle

Kunstmatige intelligentie (AI) transformeert verschillende industrieën en verandert de manier waarop bedrijven opereren. Hoewel Python vaak beschouwd wordt als de standaardtaal voor AI-ontwikkeling, biedt Java robuuste bibliotheken en frameworks die het een even sterke kandidaat maken voor het creëren van AI-gebaseerde toepassingen. In dit artikel verkennen we het gebruik van Java en Gradle voor AI-ontwikkeling door het bespreken van populaire bibliotheken, het verstrekken van codevoorbeelden en het demonstreren van volledig werkende voorbeelden.

Java-bibliotheken voor AI-ontwikkeling

Java biedt verschillende krachtige bibliotheken en frameworks voor het bouwen van AI-toepassingen, waaronder:

• Deeplearning4j (DL4J) – Een diepe leerbibliotheek voor Java die een platform biedt voor het bouwen, trainen en implementeren van neurale netwerken, DL4J ondersteunt verschillende neurale netwerkarchitectuur en biedt GPU-versnelling voor snellere berekeningen.
• Weka – Een verzameling machine learning algoritmen voor data mining taken, Weka biedt tools voor data voorbewerking, classificatie, regressie, clustering en visualisatie.
• Encog – Een machine learning framework ondersteunt verschillende geavanceerde algoritmen, waaronder neurale netwerken, support vector machines, genetische programmering en Bayesian netwerken

Het instellen van afhankelijkheden met Gradle

Om AI-ontwikkeling in Java te beginnen met behulp van Gradle, stel je de vereiste afhankelijkheden in je project in door het volgende toe te voegen aan je build.gradle bestand:

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

Codevoorbeelden

Het bouwen van een eenvoudig neuronaal netwerk met DL4J

Dit voorbeeld demonstreert het creëren van een basis neuronaal netwerk met behulp van de Deeplearning4j (DL4J) bibliotheek. De code stelt een tweelaags neuronaal netwerk op dat bestaat uit een DenseLayer met 4 invoerneuronen en 10 uitvoerneuronen, met behulp van de ReLU-activatiefunctie, en een OutputLayer met 10 invoerneuronen en 3 uitvoerneuronen, met de Softmax-activatiefunctie en Negative Log Likelihood als verliesfunctie. Het model wordt vervolgens geïnitialiseerd en kan verder getraind worden op gegevens en gebruikt worden voor voorspellingen.

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();
    }
}

Classificatie met behulp van Weka

Dit voorbeeld laat zien hoe je de Weka-bibliotheek kunt gebruiken voor classificatie op de Iris-dataset. De code laadt de dataset vanuit een ARFF-bestand, stelt de klasse-attribuut (het attribuut dat we willen voorspellen) in als het laatste attribuut in de dataset, bouwt een Naive Bayes-classificator met behulp van de geladen gegevens en classificeert een nieuw exemplaar.

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));
    }
}

Conclusie

Java, met zijn rijke eco-systeem van bibliotheken en frameworks voor AI-ontwikkeling, is een geschikte keuze voor het bouwen van AI-gebaseerde toepassingen. Door populaire bibliotheken zoals Deeplearning4j, Weka en Encog te gebruiken, en Gradle als buildtool, kunnen ontwikkelaars krachtige AI-oplossingen creëren met behulp van de vertrouwde Java-programmeertaal.

De voorgestelde codevoorbeelden laten zien hoe eenvoudig het is om AI-toepassingen in te stellen en te configureren met behulp van Java en Gradle. Het DL4J-voorbeeld laat zien hoe je een eenvoudig diep leer model kunt maken dat kan worden toegepast op taken zoals afbeeldingsherkenning of natuurlijke taalverwerking. Het Weka-voorbeeld demonstreert hoe je Java en de Weka-bibliotheek kunt gebruiken voor machinaal leren taken, met name classificatie, wat waardevol kan zijn voor het implementeren van machinaal leren oplossingen in Java-toepassingen, zoals het voorspellen van klantenverlies of het classificeren van e-mails als spam of niet spam.

Happy Learning!!