Como integrar IA em aplicações Java

#Java
#Inteligência Artificial (IA)

Nesse artigo você vai encontrar:

🚀 Introdução à IA com Java
🔗 APIs REST
☁️ Azure e Java: recursos em nuvem para IA
🗃️ Compreendendo Bancos de Dados Vetoriais
📚 Escolhendo Bibliotecas e Frameworks para IA em Java
🧩 LangChain4j: LLMs no Ecossistema Java
🧹 Preparação de Dados para Aprendizado de Máquina
🎯 Treinamento e Avaliação de Modelos
⚙️ Otimização e Ajuste de Modelos
💻 Java e Aprendizado de Máquina: Uma Combinação?
🤖 Técnicas Avançadas de IA em Java
🔮 O Presente e Futuro da IA com Java
✍️ Conclusão
📚 Referências

1. 🚀 Introdução à IA com Java

A Inteligência Artificial se tornou uma escolha popular em projetos Java graças à robustez da linguagem, sua independência de plataforma e o amplo suporte da comunidade. Esses fatores fazem do Java uma base sólida para aplicações modernas com IA.

Existem diversas formas de integrar IA em sistemas Java. Algumas das mais comuns incluem o uso de bibliotecas específicas da linguagem, APIs REST com serviços externos e plataformas em nuvem, como o Azure, que oferecem modelos prontos para uso.

Embora a maior parte dos exemplos de uso de modelos de linguagem (LLMs) utilize Python, ferramentas como LangChain4j trazem essa abordagem para o ecossistema Java. Por isso, daremos atenção especial ao LangChain nesta seção, para facilitar a transição do conhecimento.

2. 🔗 APIs REST

Uma forma de integrar IA no Java também é a partir APIs REST, incorporando em aplicativos Java existentes e implantadas usando o TensorFlow Serving, entre outras plataformas. O Spring Boot é considerado um dos frameworks de arquitetura de microsserviços Java mais maduros e flexíveis disponíveis atualmente.

3. ☁️ Azure e Java: recursos em nuvem para IA

A Azure disponibiliza alguns recursos de aprendizado para desenvolvedores Java que estão começando a criar aplicativos de IA nesse site aqui.

Microsoft Azure oferece uma gama de ferramentas específicas para desenvolvedores Java tais como:

reconhecimento de linguagem natural
pesquisa na nuvem com IA aos seus aplicativos
Conversão de fala em texto, conversão de texto em fala, tradução e reconhecimento de locutor

4. 🗃️ Compreendendo Bancos de Dados Vetoriais

Para Soluções de IA está se falando mais sobre estruturar os dados em bancos de dados vetoriais, mas você sabe o que isso quer dizer? Pense em um banco vetorial como um 'Google de significados': ele busca o mais parecido, não o mais exato.

Um Banco de Dados Vetorial indexa e armazena embeddings de Vetores para recuperação rápida e busca por similaridade. Um embedding de vetores é apenas uma lista de números que representa os dados de forma diferente.

Alguns exemplos de bancos vetoriais que podem ser utilizados com Java são: Elasticsearch e Vespa.

5. 📚Escolhendo Bibliotecas e Frameworks para IA em Java

A IA em Java conta com diversas bibliotecas e frameworks, cada um indicado para diferentes tipos de projeto. A escolha depende da técnica de IA usada, da complexidade desejada e do nível de suporte da comunidade.

Agora passaremos por algumas subssões apresentando mais detalhes sobre cada uma das frameworks apresentadas.

🔹 Weka

Weka é ideal para quem está começando. Com uma interface amigável, oferece um amplo conjunto de algoritmos prontos para tarefas como classificação, regressão e agrupamento.

Weka suporta tarefas como classificação, regressão, clustering e mineração de regras. Possui uma GUI intuitiva que facilita explorar dados e aplicar algoritmos sem precisar programar muito, além de suportar pré-processamento e visualização de dados.

Ela trabalha principalmente com o formato ARFF, que descreve dados e seus atributos, mas também importa CSV, JSON e outros formatos. Pode carregar dados de arquivos locais, URLs e bancos de dados, tornando a integração flexível.

Weka conta com um conjunto amplo de algoritmos, incluindo árvores de decisão, Naive Bayes, regressão, métodos em conjunto e muito mais, cobrindo diversas necessidades de machine learning.

Embora seja fácil de usar e extensível via plugins, Weka não é ideal para grandes volumes de dados, pois carrega tudo em memória, e não suporta mineração multi-relacional nem modelagem sequencial nativa.

O sistema de extensões permite adicionar funcionalidades, como integração com Hadoop, análise de séries temporais e computação distribuída, tornando o Weka mais poderoso para tarefas específicas.

Se ficou interessado em entender mais dessa framework aqui está o site oficial.

🔹 DeepLearning4j (DL4J)

DL4J é um framework open-source de deep learning para Java e JVM, criado pela Skymind. Permite criar, treinar e implementar redes neurais profundas, integrando-se facilmente a sistemas Java empresariais, com foco em escalabilidade e desempenho.

A importância do DL4J está na possibilidade de usar deep learning diretamente em projetos Java, facilitando a adoção de IA em empresas sem mudar de linguagem. Ele suporta grandes volumes de dados e diversos tipos de redes neurais, como CNNs e RNNs.

DL4J oferece recursos avançados como integração com big data (Hadoop, Spark), importação de modelos do TensorFlow ou Keras, além do DataVec para pré-processamento, garantindo flexibilidade e facilidade no fluxo de trabalho.

Para usar, configure o ambiente com JDK 8+, Maven ou Gradle e, opcionalmente, GPU com CUDA. Depois, adicione as dependências necessárias ao seu projeto para incluir DL4J, ND4J e DataVec.

A arquitetura do DL4J baseia-se em camadas de neurônios artificiais. Através de uma API de alto nível, é possível definir redes complexas e treinar modelos, semelhante a frameworks como Keras.

No desenvolvimento, você define a arquitetura da rede, inicializa o modelo, prepara dados (ex: MNIST), adiciona listeners para monitorar o treino, executa o treinamento, avalia o desempenho e salva o modelo para uso futuro.

Para contexturalizar melhor como fica no código, abaixo apresento a definição da configuração da rede e a inicialização do modelo.

MultiLayerConfiguration config = new NeuralNetConfiguration.Builder()
  .seed(123)
  .updater(new Adam(0.001))
  .list()
  .layer(new DenseLayer.Builder()
      .nIn(784)
      .nOut(256)
      .activation(Activation.RELU)
      .build())
  .layer(new OutputLayer.Builder(LossFunctions.LossFunction.NEGATIVELOGLIKELIHOOD)
      .nIn(256)
      .nOut(10)
      .activation(Activation.SOFTMAX)
      .build())
  .build();
  
MultiLayerNetwork model = new MultiLayerNetwork(config);
model.init();

🔹 TensorFlow

TensorFlow oferece uma API Java para construir, treinar e executar modelos de aprendizado de máquina diretamente em aplicativos Java. Isso permite integrar IA avançada sem sair do ecossistema Java.

Com TensorFlow Java, é possível criar gráficos computacionais, treinar modelos, avaliar desempenho e realizar inferência para previsões em tempo real.

Ele suporta integração com outras bibliotecas Java para manipulação de dados e visualização, ampliando seu uso em projetos complexos.

TensorFlow Java roda em Java 8+, compatível com Windows, macOS e Linux, sendo multiplataforma e robusto para ambientes corporativos.

Para usar, basta adicionar a dependência tensorflow-core-platform via Maven ou Gradle, que inclui as bibliotecas nativas para todas as plataformas compatíveis.

Também há versões específicas para otimização, como suporte a Intel MKL-DNN e CUDA GPU, que podem ser incluídas conforme a necessidade do projeto.

🔹H2O.ia

H2O.ai é uma plataforma com foco em facilidade de uso e escalabilidade. Ela oferece recursos para automação de machine learning, interpretabilidade de modelos e implantação, sendo útil para aplicações empresariais.

Para começar com a plataforma open source H2O, faça o download do arquivo h2o.jar no site oficial. Para iniciar o H2O, abra o terminal na pasta onde está o arquivo e execute:

java -jar h2o.jar

No console web do H2O, importe o arquivo CSV usando a opção “Import Files” no menu Data. Depois, liste os frames disponíveis e faça o parsing para visualizar o dataset. Para seguir boas práticas, divida o conjunto em treino e teste com a função “Split Frame”, usando uma proporção comum de 80/20 ou outra de sua preferência.

Para treinar o modelo, selecione o algoritmo Random Forest no menu Model, configure os parâmetros de treino, validação e a coluna resposta, e clique em “Build Model”. Se preferir não escolher o algoritmo manualmente, use a função AutoML, que treina múltiplos modelos e apresenta uma lista ordenada dos melhores.

Depois de treinar, você pode baixar dois arquivos importantes: um JAR com as classes do modelo e o pacote MOJO com o modelo treinado.

Para usar o modelo em uma aplicação Java, adicione os arquivos JAR na pasta libs do seu projeto e inclua a dependência no pom.xml:

<dependency>
  <groupId>ai.h2o</groupId>
  <artifactId>h2o-genmodel</artifactId>
  <version>1.0</version>
  <scope>system</scope>
  <systemPath>${project.basedir}/libs/h2o-genmodel.jar</systemPath>
</dependency>

No código Java, para exeplificar vamos imaginar um dataset de classificação da flor iris. Carregue o arquivo MOJO e faça a predição passando as características da flor:

MojoModel mojoModel = MojoModel.load("libs/mojo.zip");
EasyPredictModelWrapper model = new EasyPredictModelWrapper(mojoModel);

RowData row = new RowData();
row.put("sepal.length", 5.1);
row.put("sepal.width", 3.4);
row.put("petal.length", 4.6);
row.put("petal.width", 1.2);

MultinomialModelPrediction prediction = model.predictMultinomial(row);

System.out.println("Predicted flower: " + prediction.label);
for (int i = 0; i < prediction.classProbabilities.length; i++) {
  System.out.println("Class " + i + ": " + prediction.classProbabilities[i]);
}

Esse processo garante que você consiga criar, treinar e usar modelos de machine learning de forma simples, aproveitando os recursos do H2O com Java. Mais detalhes de como usar nesse link.

Apache Spark MLlib

Apache Spark MLlib é indicado para projetos com grande volume de dados. Isso porque contém exclusivamente algoritmos de machine learning que podem ser executados em paralelo, ou seja, fazem melhor aproveitamento do poder computacional disponível.

E mesmo podendo ser utilizado no contexto de Big Data o processo começar a utilizar o Apache Spark é relativamente simples, como mostrado no código abaixo:

// configure para criar o contexto
SparkConf conf = new SparkConf()
.setAppName("Main")
.setMaster("local[2]");
JavaSparkContext sc = new JavaSparkContext(conf);

Depois de configurar é necessário conectar com os seus dados, que podem estar em arquivo(s) ou em um dataset com JavaRDD (Resilient Distributed Dataset). O Spark MLlib oferece diversos tipos de dados, tanto locais quanto distribuídos, para representar os dados de entrada e os rótulos correspondentes.

Spark MLlib é equipado com APIs para oferecer alguns insights na análise estatistica, usando:

MultivariateStatisticalSummary summary = Statistics.colStats(inputData.rdd());

Pode se consultar a média, variância, número de zeros e outras metricas, além de facilmente poder verificar correlações como pearson e spearman:

Matrix correlMatrix = Statistics.corr(inputData.rdd(), "pearson");

Após a análise exploratória dos dados, a próxima etapa envolve o treinamento e a avaliação do modelo. O MLlib oferece uma variedade de algoritmos para isso. Além disso, há suporte nativo para salvar e carregar modelos treinados, facilitando a reutilização e a implantação em ambientes de produção.

6. 🧩LangChain4j

LangChain4j traz os principais conceitos do LangChain para o ecossistema Java. Embora não exista uma versão oficial do LangChain para Java, a comunidade criou o LangChain4j, compatível com Java 8+ e Spring Boot 2/3.

Ideal para quem deseja criar aplicações com LLMs em Java, usando estruturas como prompts, memória, recuperação de contexto, chains e agents.

📦 Instalação

Adicione ao seu pom.xml:

<dependency>
<groupId>dev.langchain4j</groupId>
<artifactId>langchain4j</artifactId>
<version>0.23.0</version>
</dependency>

🧱 Componentes Essenciais

🔹 1. Modelos e Prompts

Criação de prompts dinâmicos e interação com modelos da OpenAI:

PromptTemplate promptTemplate = PromptTemplate.from("Conte uma piada {{adjective}} sobre {{content}}.");
Map<String, Object> vars = Map.of("adjective", "engraçada", "content", "computadores");
Prompt prompt = promptTemplate.apply(vars);

ChatLanguageModel model = OpenAiChatModel.builder()
.apiKey("SUA_API_KEY")
.modelName(GPT_3_5_TURBO)
.temperature(0.3)
.build();

String resposta = model.generate(prompt.text());

🔹 2. Memória (Conversas com Contexto)

Permite lembrar interações anteriores:

ChatMemory memoria = TokenWindowChatMemory.withMaxTokens(300, new OpenAiTokenizer(GPT_3_5_TURBO));

memoria.add(userMessage("Olá, me chamo Ana"));
AiMessage resposta = model.generate(memoria.messages()).content();
System.out.println(resposta.text()); // Olá Ana! Como posso te ajudar?

memoria.add(resposta);
memoria.add(userMessage("Qual é o meu nome?"));
AiMessage novaResposta = model.generate(memoria.messages()).content();
System.out.println(novaResposta.text()); // Seu nome é Ana.

🔹 3. Recuperação (RAG)

Útil para usar dados externos como base para respostas:

Document doc = FileSystemDocumentLoader.loadDocument("dados.txt");
DocumentSplitter splitter = DocumentSplitters.recursive(100, 0, new OpenAiTokenizer(GPT_3_5_TURBO));
List<TextSegment> segmentos = splitter.split(doc);

// Embeddings + Armazenamento
EmbeddingModel embeddingModel = new AllMiniLmL6V2EmbeddingModel();
List<Embedding> embeddings = embeddingModel.embedAll(segmentos).content();
EmbeddingStore<TextSegment> store = new InMemoryEmbeddingStore<>();
store.addAll(embeddings, segmentos);

// Recuperação baseada em pergunta
Embedding perguntaEmbedding = embeddingModel.embed("Quem é Simpson?").content();
List<EmbeddingMatch<TextSegment>> relevantes = store.findRelevant(perguntaEmbedding, 3, 0.7);

🔁 Construindo Aplicações Complexas

🔸 Chains (Fluxos de Execução)

Permitem encadear etapas de forma modular:

ConversationalRetrievalChain chain = ConversationalRetrievalChain.builder()
.chatLanguageModel(model)
.retriever(EmbeddingStoreRetriever.from(store, embeddingModel))
.chatMemory(MessageWindowChatMemory.withMaxMessages(10))
.promptTemplate(PromptTemplate.from("Pergunta: {{question}}\\n\\nBase: {{information}}"))
.build();

String resposta = chain.execute("Quem é Simpson?");

🔸 Agents (Comportamento Inteligente com Ferramentas)

Permitem usar o modelo como motor de decisão + ferramentas:

public static class Calculadora {
@Tool("Calcula o tamanho de uma string")
int tamanho(String s) { return s.length(); }

@Tool("Soma dois números")
int soma(int a, int b) { return a + b; }
}

interface Assistente {
String chat(String mensagem);
}

Assistente assistente = AiServices.builder(Assistente.class)
.chatLanguageModel(OpenAiChatModel.withApiKey("SUA_API_KEY"))
.tools(new Calculadora())
.chatMemory(MessageWindowChatMemory.withMaxMessages(10))
.build();

String resposta = assistente.chat("Qual a soma das letras de 'linguagem' e 'modelo'?");
System.out.println(resposta); // A soma das letras é 13.

7. 🧹Preparação de Dados para Aprendizado de Máquina

O primeiro passo em um projeto de IA é garantir que os dados estejam prontos para o aprendizado. Em Java, bibliotecas como o Weka oferecem ferramentas robustas para o pré-processamento de dados. É possível limpar, transformar e normalizar conjuntos de dados antes de usá-los em modelos. Essa etapa é essencial para melhorar a precisão e a eficiência dos algoritmos de aprendizado.

8. 🎯 Treinamento e Avaliação de Modelos

Após preparar os dados, o próximo passo é treinar os modelos. Usando bibliotecas como Weka ou Deeplearning4j, é possível aplicar algoritmos de classificação, regressão e clustering. Avaliar o modelo envolve comparar previsões com os dados reais, usando métricas como acurácia, precisão, recall e F1-score, garantindo que o modelo generalize bem para novos dados.

9. ⚙️Otimização e Ajuste de Modelos

Com um modelo treinado e avaliado, é hora de aprimorar seu desempenho. Isso pode ser feito por meio de técnicas como validação cruzada, ajuste de hiperparâmetros e uso de algoritmos de busca. Ferramentas como H2O.ai ou o próprio Weka facilitam esse processo, ajudando a encontrar a melhor combinação de parâmetros para aumentar a eficácia do modelo.

10. 💻 Java e Aprendizado de Máquina: Uma Combinação?

Alguns dos aspectos positivos que se destacam no caso do Java como uma escolha popular e líder para projetos de ML são:

Comunidade ativa

Com uma grande base de desenvolvedores, Java oferece um ecossistema rico em bibliotecas e frameworks úteis para ML. A comunidade ativa facilita a resolução de problemas e o compartilhamento de boas práticas.

Independência de plataforma

Java garante que o código seja portável entre diferentes sistemas operacionais, o que é ideal para projetos de ML que precisam rodar em ambientes diversos.

Orientação a Objetos

A orientação a objetos do Java favorece a modularização do código, facilitando a organização, manutenção e reuso. Isso é especialmente útil em aplicações de ML que tendem a crescer em complexidade.

11. 🤖Técnicas Avançadas de IA em Java

Com mais experiência, é possível explorar técnicas avançadas de IA no ecossistema Java, ampliando as possibilidades de aplicações inteligentes.

🔹 Processamento de Linguagem Natural (PLN)

O PLN permite que máquinas compreendam e processem linguagem humana. Bibliotecas como Stanford CoreNLP e Apache OpenNLP facilitam tarefas como análise de sentimentos, sumarização de textos e tradução automática.

🔹 Visão Computacional

Essa técnica permite extrair informações de imagens e vídeos. Frameworks como OpenCV, compatíveis com Java, oferecem ferramentas para reconhecimento facial, detecção de objetos e processamento de imagens em geral.

🔹 Aprendizado por reforço

Embora mais comum em pesquisas, o aprendizado por reforço também pode ser implementado no Java com frameworks como RLlib, especialmente quando integrados a ambientes simulados.

12. 🔮O Presente e Futuro de IA com Java

Só no último ano é possivél encontrar pesquisas que mostram IA com Java sendo utilizado em diversas áreas como:

Entre outros projetos que integram aplicações Java em Cloud buscando soluções cada vez mais escaláveis.

À medida que a IA se torna mais acessível e presente em múltiplas áreas, é natural que tecnologias maduras como o Java comecem a incorporar soluções de IA com mais frequência. Isso é especialmente válido em empresas que já possuem uma base sólida em Java.

13. ✍️Conclusão

Os exemplos que você viu aqui mostram que, mesmo com menos hype, o Java tem potencial real para construir soluções inteligentes, escaláveis e há sinais de crescimento. A evolução de frameworks como LangChain4j e integrações com ferramentas populares mostram que há movimento nesse espaço.

Embora a demanda por IA em Java ainda seja limitada em comparação com Python, isso pode mudar com a expansão das tecnologias e a necessidade de adaptação em diferentes contextos. Manter-se atualizado e explorar novas ferramentas será essencial para acompanhar essa transformação.