Descomplicando Java com IA: Automatizando tarefas com IA em projetos Java
✨Introdução
A inteligência artificial não é mais uma promessa e sim uma realidade. Como desenvolvedor, chego à conclusão de que hoje a IA tem um papel crucial no desenvolvimento de software. No começo, utilizávamos para gerar alguns textos, hoje são capazes de gerar imagens, até mesmo código. A IA vem revolucionando quando o assunto são sistemas.
Nos dias de hoje, você, programador, não precisa sofrer horas com tarefas que exigiam muito trabalho manual, como análise de dados, classificação de informações e até mesmo suporte ao cliente. Tudo isso pode ser facilmente automatizado por modelos de IA, o que aumenta sua produtividade de forma inimaginável.
E quando o assunto é IA, Java não fica para trás. Afinal, estamos falando da linguagem mais incorporada no meio corporativo e que é totalmente apta a integrar soluções com base em Inteligência Artificial. Seja utilizando bibliotecas específicas ou integrando APIs, como a própria OpenAI, é possível transformar aplicações Java em sistemas mais inteligentes e eficientes.
Neste artigo, quero descomplicar o uso de Java com IA, abordando especificamente como automatizar tarefas com IA em projetos, com exemplos práticos, códigos comentados e dicas de ferramentas que podem ser aplicadas no seu dia a dia como desenvolvedor.
🤖O que é automação com IA?
O conceito de automação e realizar tarefas sem intervenção humana com regras fixas, mas quando falamos de automação com IA (inteligência artificial) é o processo no qual incluímos algoritmos inteligentes para realizar tais tarefas, indo além da automação tradicional.
Enquanto a automação tradicional faz tarefas repetitivas, como copiar arquivos ou enviar e-mails, a automação com IA aprende com os dados, toma decisões baseadas no contexto e se adapta conforme o ambiente. Ela é simplesmente a velocidade da tradicional com um toque de inteligência.
📌 Exemplos práticos em projetos Java:
- Análise de sentimentos de feedbacks: Interpretar se um comentário de usuário é positivo, negativo ou neutro.
- Geração de relatórios automáticos: Com base em dados brutos, a IA pode gerar resumos executivos ou insights.
- Classificação de documentos: Identificar automaticamente o tipo de um arquivo (nota fiscal, currículo, contrato, etc.).
- Chatbots inteligentes: Atender clientes usando linguagem natural, com respostas relevantes e contextualizadas.
🧰Ferramentas de IA que se integram bem com Java
O ambiente Java oferece diversas formas de você integras soluções de Ias, tanto usando as bibliotecas nativas quanto por APIs externas baseadas em nuvem.com essa flexibilidade vc pode escolher a forma ideal baseada no seu projeto, desde soluções mais básicas ates as mais complexas.
☁️ APIs baseadas em IA (Cloud)
São serviços oferecidos por grandes provedores, esses serviços estão disponíveis na forma de APIs, e você pode acessá-los por meio de requisições HTTP. Se você está programando em Java, pode integrar esses serviços usando bibliotecas bem conhecidas como HttpClient, Retrofit ou OkHttp. Assim, fica muito mais fácil aproveitar o poder da IA nas suas aplicações.
OpenAI API
- Permite geração de texto, resumo, classificação, tradução, entre outras tarefas.
- Ideal para análise de linguagem natural e automação de conteúdo.
Google Cloud AI (Vertex AI)
- Oferece reconhecimento de imagem, visão computacional, tradução, etc.
- Integração fácil com bibliotecas REST e SDKs Java.
Azure Cognitive Services
- Recursos como análise de sentimentos, reconhecimento facial e linguagem natural.
- Suporte via REST e SDKs para Java.
IBM Watson
- Foco em NLP, conversação (chatbots), e IA explicável.
- APIs bem documentadas com integração pronta para aplicações corporativas.
🧩 Bibliotecas Java para IA e Machine Learning
Se o projeto exige maior controle sobre o modelo ou precisa funcionar offline, as bibliotecas nativas de Java para IA são uma excelente escolha:
Deeplearning4j (DL4J)
- Framework poderoso para deep learning em Java e Scala.
- Compatível com redes neurais, CNNs e RNNs. Suporta GPUs.
Weka
- Ferramenta clássica de aprendizado de máquina, fácil de usar.
- Ideal para tarefas como classificação, regressão e clustering.
- Pode ser usada com interface gráfica ou via código Java.
Smile (Statistical Machine Intelligence and Learning Engine)
- Biblioteca rápida e leve para tarefas de machine learning e estatística.
- Suporta regressão, árvores de decisão, clustering, NLP, entre outros.
🔗 Integração via HTTP/REST
Mesmo que a biblioteca ou serviço não tenha um SDK oficial para Java, a integração é possível via requisições HTTP com bibliotecas padrão, como:
// Cria um cliente HTTP padrão (Java 11+)
HttpClient client = HttpClient.newHttpClient();
// Constrói a requisição HTTP POST
HttpRequest request = HttpRequest.newBuilder()
// Define a URL da API que será chamada
.uri(URI.create("https://api.exemplo.com/analisar"))
// Adiciona o cabeçalho de autenticação (token Bearer)
.header("Authorization", "Bearer sua-chave-api")
// Define o método POST e envia o corpo da requisição (payload)
.POST(HttpRequest.BodyPublishers.ofString(payload))
// Finaliza a construção da requisição
.build();
// Envia a requisição e recebe a resposta da API (sincronamente)
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
// Imprime o corpo da resposta no console
System.out.println(response.body());
💬Exemplo Prático 1 – Geração de Resumo de Texto com OpenAI
A primeira aplicação que desenvolvi e uma das mais úteis é a geração automática de resumos de texto. Pode ser muito útil para resumir seus relatórios, feedback de usuário ou até documentos técnicos. A API da OpenAI, com o modelo gpt-3.5-turbo ou gpt-4, permite que você envie um texto e receba um resumo conciso e bem estruturado. Vamos ver como isso pode ser feito em Java, usando a biblioteca HttpClient (obs: disponível a partir do Java 11).
✅ Etapas:
- Criar o payload (conteúdo da requisição) com o texto que será resumido.
- Enviar a requisição
POSTpara a API da OpenAI. - Receber e processar a resposta JSON com o resumo.
💡 Requisitos:
- Java 11 ou superior
- Chave de API da OpenAI (https://platform.openai.com)
// Importa as bibliotecas necessárias para trabalhar com HTTP em Java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.net.http.HttpRequest.BodyPublishers;
public class ResumoComOpenAI {
public static void main(String[] args) throws Exception {
// Substitua por sua chave da API OpenAI obtida em https://platform.openai.com/account/api-keys
String apiKey = "SUA_CHAVE_OPENAI";
// Texto original que será enviado para a IA gerar um resumo
String textoOriginal = "O Java é uma linguagem de programação amplamente usada em ambientes corporativos. "
+ "Sua robustez e portabilidade permitem o desenvolvimento de aplicações escaláveis "
+ "em diversas áreas, incluindo sistemas bancários, aplicações web e até integrações com inteligência artificial.";
// Prompt enviado para o modelo da OpenAI: estamos pedindo um resumo em 3 frases
String prompt = "Resuma o seguinte texto em 3 frases:\n" + textoOriginal;
// Corpo da requisição em formato JSON, usando o modelo gpt-3.5-turbo no modo de chat
String requestBody = """
{
"model": "gpt-3.5-turbo",
"messages": [
{"role": "user", "content": "%s"}
]
}
""".formatted(prompt); // Formata o JSON inserindo o conteúdo do prompt
// Criação da requisição HTTP POST para a API da OpenAI
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("https://api.openai.com/v1/chat/completions")) // URL da API de chat da OpenAI
.header("Content-Type", "application/json") // Informa que estamos enviando JSON
.header("Authorization", "Bearer " + apiKey) // Autenticação via Bearer Token
.POST(BodyPublishers.ofString(requestBody)) // Corpo da requisição com o JSON criado
.build();
// Criação de um cliente HTTP
HttpClient client = HttpClient.newHttpClient();
// Envio da requisição e obtenção da resposta como String
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
// Exibição do conteúdo da resposta no console
System.out.println("Resposta da OpenAI:");
System.out.println(response.body());
}
}
📌 Resultado esperado:
O modelo retornará um JSON com o conteúdo gerado. Basta extrair o campo choices[0].message.content, que contém o resumo, como por exemplo:
"Java é uma linguagem robusta e portátil. É amplamente utilizada em ambientes corporativos. Sua aplicação vai de sistemas bancários a integrações com IA."
🗂️Exemplo Prático 2 – Classificação de Dados com Weka
Um dos projetos que vocês como desenvolvedor maias vai se deparar e a classificação de dados. Com o Weka, uma biblioteca consolidada para o aprendizado de maquina, é possível treinar modelos e aplicá-los para classificar automaticamente dados novos, como arquivos, formulários, ou registros de clientes.
Neste exemplo, vamos:
- Treinar um modelo de classificação com Weka.
- Salvar o modelo treinado.
- Usar esse modelo para classificar novos dados automaticamente.
🧠 Cenário prático:
Imagine que seu sistema Java recebe planilhas com feedbacks de usuários (positivos ou negativos). Você quer automatizar a classificação do sentimento com base em exemplos anteriores, economizando tempo do time de análise.
✅ Etapa 1 – Dependência do Weka
Adicione o Weka ao seu projeto Java. Se estiver usando Maven:
<dependency>
<groupId>nz.ac.waikato.cms.weka</groupId>
<artifactId>weka-stable</artifactId>
<version>3.8.6</version>
</dependency>
✅ Etapa 2 – Dataset de exemplo (ARFF)
Use um arquivo .arff com dados de treinamento. Exemplo: feedbacks.arff
@relation feedback
@attribute texto string
@attribute sentimento {positivo,negativo}
@data
"gostei muito do produto",positivo
"não funcionou como esperado",negativo
"ótimo atendimento",positivo
"péssima experiência",negativo
✅ Etapa 3 – Código para Treinamento e Classificação
// Importa as principais classes do Weka para classificação, manipulação de dados e filtros
import weka.classifiers.bayes.NaiveBayes;
import weka.classifiers.Classifier;
import weka.core.Instances;
import weka.core.converters.ConverterUtils.DataSource;
import weka.core.Instance;
import weka.filters.Filter;
import weka.filters.unsupervised.attribute.StringToWordVector;
import java.io.*;
public class ClassificadorFeedback {
// Caminhos dos arquivos de treino e do modelo serializado
private static final String ARQUIVO_TREINO = "feedbacks.arff";
private static final String MODELO_SALVO = "modelo_feedback.model";
public static void main(String[] args) throws Exception {
// 1. Carrega os dados de treinamento a partir do arquivo ARFF
DataSource source = new DataSource(ARQUIVO_TREINO);
Instances dados = source.getDataSet();
// Define qual coluna representa a classe (a última coluna)
dados.setClassIndex(dados.numAttributes() - 1);
// 2. Aplica o filtro de vetorização de texto (converte strings em vetores numéricos)
StringToWordVector filtro = new StringToWordVector();
filtro.setInputFormat(dados); // Usa os dados como base para configurar o filtro
// Aplica o filtro para transformar os dados originais em dados vetorizados
Instances dadosFiltrados = Filter.useFilter(dados, filtro);
// 3. Treina um modelo de classificação usando o algoritmo NaiveBayes
Classifier modelo = new NaiveBayes();
modelo.buildClassifier(dadosFiltrados);
// 4. Serializa o modelo e o filtro para uso posterior (salva em arquivo)
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(MODELO_SALVO));
oos.writeObject(modelo); // Salva o modelo treinado
oos.writeObject(filtro); // Salva o filtro usado na vetorização
oos.close();
System.out.println("Modelo treinado e salvo com sucesso.");
// 5. Agora vamos classificar um novo texto
String textoNovo = "o suporte foi horrível";
// Cria uma nova instância baseada na estrutura dos dados originais (vazia por enquanto)
Instances novaBase = new Instances(dados, 0);
// Cria um vetor de atributos, com o valor do texto na primeira coluna
double[] valores = new double[novaBase.numAttributes()];
valores[0] = novaBase.attribute(0).addStringValue(textoNovo); // adiciona a string
// Cria a nova instância e adiciona à base
novaBase.add(new weka.core.DenseInstance(1.0, valores));
novaBase.setClassIndex(novaBase.numAttributes() - 1); // define a coluna da classe
// 6. Reabre o modelo e o filtro que foram salvos
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(MODELO_SALVO));
Classifier modeloCarregado = (Classifier) ois.readObject();
StringToWordVector filtroCarregado = (StringToWordVector) ois.readObject();
ois.close();
// Aplica o mesmo filtro ao novo texto
Instances entradaFiltrada = Filter.useFilter(novaBase, filtroCarregado);
// Classifica a instância com o modelo carregado
double resultado = modeloCarregado.classifyInstance(entradaFiltrada.firstInstance());
// Converte o valor numérico da classe para o nome (ex: "positivo", "negativo")
String classePrevista = novaBase.classAttribute().value((int) resultado);
System.out.println("Classificação: " + classePrevista);
}
}
📝 Explicação passo a passo:
- StringToWordVector: converte o texto para um vetor numérico (essencial para algoritmos ML).
- NaiveBayes: algoritmo simples e eficaz para texto.
- Modelo serializado: permite reaproveitar o modelo treinado em outras execuções.
- Entrada de texto nova: recebe uma string nova e classifica com base no modelo.
📌 Resultado
Se você executar o código com "o suporte foi horrível", o sistema classificará como negativo.
Exemplo Prático 3 – Chatbot com IA (via API)
Os chatbots tradicionais geralmente são baseados em regras fixas, oque limita a sua flexibilidade em agir. Já quando falamos de chatbot com IA eles usam modelos de linguagem natural capazes de entender perguntas variadas e gerar respostas mais humanas.
Neste exemplo, você verá como criar um chatbot em Java que conversa com usuários usando IA via API da OpenAI (GPT).
🧠 Cenário prático:
Imagine um sistema interno de RH onde funcionários podem perguntar, por exemplo:
"Quantos dias de férias eu tenho direito?"
"Como funciona o vale-alimentação?"
Em vez de criar uma regra para cada pergunta, você envia a pergunta para uma IA baseada em linguagem natural, e ela responde de forma inteligente.
✅ Pré-requisitos
- Ter uma conta na OpenAI (https://platform.openai.com)
- Criar uma API Key válida
- Usar Java 11+ com
HttpClient
✅ Exemplo de Código Java (Chatbot via API da OpenAI)
// Importa bibliotecas necessárias para requisições HTTP e manipulação de strings
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
public class ChatbotIA {
// Sua chave de API da OpenAI – essencial para autenticar a requisição
private static final String API_KEY = "sua-api-key-aqui";
// URL do endpoint da OpenAI para o modelo GPT (Chat Completions)
private static final String ENDPOINT = "https://api.openai.com/v1/chat/completions";
public static void main(String[] args) throws Exception {
// 1. Define a pergunta que o usuário deseja fazer ao chatbot
String pergunta = "Como funciona o aviso prévio no Brasil?";
// 2. Monta o corpo da requisição no formato JSON
// - 'system': define o papel da IA (contexto)
// - 'user': mensagem real do usuário
// O 'formatted' injeta a pergunta no campo correspondente
String corpoJson = """
{
"model": "gpt-3.5-turbo",
"messages": [
{"role": "system", "content": "Você é um assistente jurídico especialista em leis trabalhistas."},
{"role": "user", "content": "%s"}
]
}
""".formatted(pergunta);
// 3. Constrói a requisição HTTP POST com os headers e o corpo JSON
// - Define o tipo de conteúdo (application/json)
// - Usa a API Key no header Authorization
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(ENDPOINT)) // Define o endereço da API
.header("Content-Type", "application/json") // Informa que estamos enviando JSON
.header("Authorization", "Bearer " + API_KEY) // Autenticação via Bearer Token
.POST(HttpRequest.BodyPublishers.ofString(corpoJson, StandardCharsets.UTF_8)) // Corpo da requisição
.build();
// 4. Cria o cliente HTTP e envia a requisição
HttpClient client = HttpClient.newHttpClient(); // Cliente HTTP padrão do Java 11+
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
// 5. Exibe a resposta da IA no console
System.out.println("Resposta da IA:");
System.out.println(response.body()); // A resposta vem em formato JSON
}
}
💡 O que o código faz:
📦 Exemplo de resposta esperada:
{
"choices": [
{
"message": {
"role": "assistant",
"content": "O aviso prévio no Brasil pode ser trabalhado ou indenizado..."
}
}
]
}
Você pode extrair o content com uma simples biblioteca de JSON como org.json, Jackson ou Gson.
🔄 Como transformar em chatbot funcional:
- Criar uma interface web (Spring Boot + Thymeleaf, React, etc.)
- Fazer uma entrada de texto para o usuário e mostrar a resposta da IA
- Armazenar conversas em banco de dados (opcional)
🚀Vantagens
Java, uma das linguagens mais utilizadas em sistemas corporativos usar da A integração de inteligência artificial (IA) e perfeito para um avanço significativo no desenvolvimento de soluções mais inteligentes, produtivas e ágeis.
Aqui a seguir listo as principais vantagens:
1. Redução de tempo em tarefas operacionais
Com a IA integrada ao seu sistema java, aquelas tarefas repetitivas como analise de documentos respostas a e-mails, classificação de dados ou processamento de feedbacks podem ser realizadas de forma automatizada.
📌 Exemplo real: um sistema que recebe formulários de clientes e já os analisa com IA, identificando urgência ou tipo de problema automaticamente, sem intervenção humana.
2. Aumento da produtividade das equipes
Com as tarefas repetivias automatizadas os profissionais estão livres para focar em atividade mais estratégicas que demanam tomada de decisões, planejamento e inovação.
💡 Exemplo: em um sistema de RH, a IA responde dúvidas frequentes sobre férias, folhas de pagamento ou benefícios, poupando tempo da equipe de atendimento.
3. Tomadas de decisão mais rápidas e inteligentes
Ao integrar IA ao back-end Java, é possível gerar insights em tempo real, sugerir ações ou até tomar decisões automatizadas com base em dados.
📊 Exemplo: uma aplicação que analisa o comportamento de clientes e sugere automaticamente promoções personalizadas com base nos dados históricos.
4. Facilidade de integração com bibliotecas e APIs de IA
Java possui ótima compatibilidade com APIs REST e bibliotecas de IA, como:
- OpenAI, Google Cloud AI, IBM Watson (via HTTP/JSON)
- Weka, Smile, Deeplearning4j (nativas em Java)
🔧 Isso permite automatizar desde tarefas simples até fluxos mais complexos com IA sem sair do ecossistema Java.
5. Escalabilidade e robustez
Ao usar IA com Java, você garante que sua solução continue escalável, segura e estável — características essenciais em ambientes corporativos.
🏢 Exemplo: uma fintech ou ERP pode automatizar processos críticos com IA sem perder confiabilidade.
6. Personalização inteligente de experiências
Sistemas com IA aprendem com os dados e se adaptam, oferecendo experiências cada vez mais relevantes para os usuários.
✨ Exemplo: uma plataforma educacional feita em Java que usa IA para sugerir novos conteúdos com base no progresso e nos interesses do aluno.
7. Competitividade e inovação
Integrar IA em aplicações Java não é mais diferencial, é sobrevivência. Automatizar com IA te coloca à frente na corrida pela inovação, além de reduzir custos e aumentar a eficiência.
🚀 Empresas que adotam IA em seus sistemas Java reduzem falhas humanas, otimizam processos e melhoram a experiência do usuário.
⚠️Desafios e Cuidados ao Integrar IA em Projetos Java
Apesar das inúmeras vantagens, automatizar tarefas com IA em sistemas Java exige atenção a desafios técnicos, financeiros e éticos. Entender esses pontos é essencial para adotar soluções robustas, seguras e sustentáveis. A seguir, os principais desafios e como lidar com eles:
1. Custos de uso de APIs de IA
APIs como OpenAI, Google Cloud e IBM Watson cobram por requisição ou volume de tokens/dados. Em sistemas com alta demanda, o custo pode crescer rapidamente.
Cuidados:
- Otimize os prompts (ex: respostas curtas, sem redundância).
- Faça cache de respostas frequentes.
- Avalie planos e limites de uso das APIs.
📌 Dica prática: implemente monitoramento de consumo e limites por usuário/sessão no backend Java.
2. Privacidade e segurança dos dados
Ao enviar dados de usuários para APIs externas, há risco de exposição de informações sensíveis, especialmente se a IA for usada para processar documentos, formulários ou conversas.
Cuidados:
- Evite enviar dados pessoais não anonimizados.
- Utilize criptografia para armazenamento e envio.
- Prefira APIs com conformidade GDPR e LGPD.
- Documente e informe o usuário sobre o uso da IA.
📌 Em sistemas críticos, considere usar modelos locais, como Weka ou Smile, em vez de serviços externos.
3. Dependência de serviços terceiros
Quando a lógica da sua aplicação depende de uma API externa, você fica sujeito a:
- Mudanças nos preços ou políticas da API.
- Quedas temporárias do serviço.
- Alterações nos modelos que afetam as respostas.
Cuidados:
- Implemente fallback (resposta padrão) para indisponibilidades.
- Mantenha uma camada de abstração entre a lógica do seu sistema e a API externa.
- Avalie a possibilidade de treinar modelos próprios com bibliotecas Java locais.
4. Latência e desempenho
Modelos de linguagem podem levar de centenas de milissegundos a alguns segundos para responder, o que impacta sistemas que exigem respostas em tempo real.
Cuidados:
- Use threads assíncronas (CompletableFuture, ExecutorService) no Java.
- Avalie fazer pré-processamentos ou respostas assíncronas com loading.
- Para tarefas pesadas, considere rodar em batch e não em tempo real.
5. Necessidade de validação humana
IA é poderosa, mas não é perfeita. Ela pode interpretar mal contextos, gerar respostas erradas ou enviesadas.
Cuidados:
- Em tarefas críticas (como jurídica, financeira, médica), mantenha validação humana.
- Exiba alertas ao usuário indicando que a resposta foi gerada por IA.
- Permita feedback sobre as respostas para treinar e refinar o sistema.
6. Curva de aprendizado e manutenção
Mesmo com ferramentas amigáveis, trabalhar com IA exige compreensão técnica, principalmente quando se usa modelos customizados ou bibliotecas como Weka ou Deeplearning4j.
Cuidados:
- Documente o código e os fluxos da IA.
- Treine a equipe de desenvolvimento.
- Automatize testes para garantir que a IA está respondendo como esperado.
🧠Conclusão
Ao longo deste artigo, vimos que automatizar tarefas com inteligência artificial em projetos Java não só é possível, como também é acessível, útil e estratégico.
Com o avanço de APIs de linguagem natural como a OpenAI, e o suporte de bibliotecas Java como Weka, Smile e Deeplearning4j, os desenvolvedores podem transformar aplicações tradicionais em sistemas mais inteligentes, produtivos e interativos.
Seja para resumir textos, classificar dados, criar chatbots ou tomar decisões baseadas em contexto, a IA abre caminho para uma nova era de automação, onde o código Java deixa de apenas executar instruções e passa a entender intenções.
✅ O que aprendemos:
- A diferença entre automação tradicional e automação com IA.
- Ferramentas e APIs que se integram facilmente com Java.
- Exemplos práticos de uso real com código comentado.
- As principais vantagens e também os cuidados necessários ao adotar IA.
🚀 Comece pequeno. Cresça com confiança.
Você não precisa aplicar IA em todos os processos de uma vez. Comece com tarefas simples e pontuais — como gerar um resumo automático ou classificar um feedback — e vá evoluindo conforme percebe os ganhos de tempo, qualidade e produtividade.
Automação com IA não é mais futurismo, é o presente das empresas que querem ser mais competitivas, humanas e inovadoras.
📚 Referências
OPENAI. Documentação da API OpenAI. 2024. Disponível em: https://platform.openai.com/docs. Acesso em: 24 jun. 2025.
HALL, Mark et al. The WEKA Data Mining Software: An Update. SIGKDD Explorations, v. 11, n. 1, p. 10–18, 2009. Disponível em: https://www.cs.waikato.ac.nz/ml/weka/. Acesso em: 24 jun. 2025.
GIBSON, Adam. Deeplearning4j: Open-Source Deep Learning for the JVM. Konduit AI, 2024. Disponível em: https://deeplearning4j.konduit.ai/. Acesso em: 24 jun. 2025.
Minhas Redes:
- K.A.I.Z.E.N - significa: "a melhoria contínua."
