Explore o novo chatbot do Developer Center! O MongoDB AI chatbot pode ser acessado na parte superior da sua navegação para responder a todas as suas perguntas sobre o MongoDB .

Junte-se a nós no Amazon Web Services re:Invent 2024! Saiba como usar o MongoDB para casos de uso de AI .
Desenvolvedor do MongoDB
Central de desenvolvedor do MongoDBchevron-right
Produtoschevron-right
MongoDBchevron-right

Um guia para novatos sobre como integrar o MongoDB com o TensorFlow usando JavaScript

Folasayo Samuel Olayemi15 min read • Published Sep 04, 2024 • Updated Sep 04, 2024
IAJavaScriptMongoDB
Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Você é novato ou guru do JavaScript e está interessado em saber como o Tensorflow.js usa o MongoDB como banco de dados? Este tutorial é para você. Neste tutorial, explicamos como você pode usar o MongoDB com Tensorflow.js, uma biblioteca que permite aos desenvolvedores executar modelos de aprendizado de máquina diretamente no navegador ou no Node.js. Essa implementação é vantajoso para desenvolvedores que procuram criar aplicativos da web que sejam escaláveis e eficientes e ofereçam suporte a conjuntos de dados complexos para aprendizado de máquina.

O que é o MongoDB?

O MongoDB é um banco de dados NoSQL de código aberto. Os bancos de dados NoSQL são eficazes para trabalhar com grandes conjuntos de dados distribuídos. O MongoDB é um banco de dados de documentos que permite escalabilidade e flexibilidade incomparáveis, além de todas as consultas e indexação necessárias.

O que é o TensorFlow?

O TensorFlow é uma plataforma de código aberto de ponta a ponta para aprendizado de máquina. É um sistema avançado para gerenciar todos os aspectos de um sistema de aprendizado de máquina. No entanto, este tutorial se concentra no uso de uma API específica do TensorFlow para desenvolver e treinar modelos de aprendizado de máquina. O TensorFlow foi desenvolvido pela equipe do Google Brain. Ele funciona por meio da criação de gráficos computacionais, que são redes de nós em que cada nó representa uma operação matemática. As bordas entre os nós representam matrizes de dados multidimensionais (tensores) que fluem entre as operações.

Casos de uso do TensorFlow

Aqui estão algumas aplicações úteis do TensorFlow.
  1. Recurso de reconhecimento de imagem: o TensorFlow é usado em aplicativos de reconhecimento de imagem, onde pode detectar objetos, face e cenários em imagens e vídeos. Esse recurso é necessário para aplicativos que vão de sistemas de segurança, onde ajuda na monitoramento ao reconhecer atividades e expressões humanos, até saúde, onde ajuda no diagnóstico de condições analisando imagens médicas. Leia mais sobre o TensorFlow para reconhecimento de imagens
  2. Processamento de linguagem natural (NLP): a capacidade do TensorFlow de lidar com grandes conjuntos de dados e algoritmos complexos o torna uma escolha ideal para tarefas de NLP. Ele capacita aplicativos como tradução de idiomas, análise de relacionamentos e chatbots, ajudan- do as máquinas a entender, interpretar e gerar linguagem humana de forma contextualmente relevante. Explore os aplicativos TensorFlow no NLP.
  3. Sistemas de recomendações: muitas empresas de e-commerce e streaming usam o TensorFlow para desenvolver seus sistemas de recomendações, que analisam o comportamento passado dos usuários para sugerir produtos ou mídia que possam ser de seu interesse. Essa personalização melhora a experiência do usuário e pode aumentar significativamente as taxas de conversão para empresas. Saiba mais sobre como criar sistemas de recomendações com o TensorFlow
  4. Documentos autônomos: o TensorFlow é usado na setor automotivo para desenvolver e melhorar sistemas para veículos autônomos. Ao processar dados de vários sensores e réplicas, os modelos baseados no TensorFlow ajudam a tomar decisões sobre a direção do veículo e evitar colisões. Veja como o TensorFlow é aplicado na direção autônoma
  5. Saúde: o TensorFlow é usado para várias tarefas, como detecção de condições e descoberta de novos métodos. Ele analisa padrões de grandes conjuntos de dados de registros médicas para prever a progresso e os resultados da saúde, facilitando o diagnóstico inicial e planos de tratamento personalizados. Descubra os aplicativos TensorFlow na área de saúde
Esses exemplos ilustram a versatilidade do TensorFlow em diferentes domínios, mostrando seu papel na promoção da inovação ao transformar a forma como os dados são interpretados e utilizados na criação de aplicativos inteligentes. Cada link de caso de uso fornecido oferece um mergulho mais profundo em como o TensorFlow é empregado em aplicativos do mundo real, fornecendo evidências de sua ampla utilidade e impacto.

Pré-requisitos

Antes de entrarmos em detalhes, verifique se você tem o seguinte instalado:
  • MongoDB: certifique-se de que o MongoDB esteja instalado e em execução em sua máquina macOS. Para obter instruções detalhadas, consulte a documentação oficial do MongoDB para baixar, instalar e iniciar o servidor MongoDB apropriado para o macOS.
  • Node.js: você precisará doNode.js para executar o JavaScript no servidor.
  • TensorFlow.js: Instale o TensorFlow.js usando npm com npm install @tensorflow/tfjs-node.
  • instalação dotenv: Antes de acessar o URI MongoDB armazenado em variáveis de ambiente, certifique-se de ter o pacotedotenv instalado em seu projeto Node.js. Esse pacote carrega variáveis de ambiente de um arquivo.env para process.env, facilitando o gerenciamento de configurações confidenciais com segurança. Instale odotenv utilizando onpm executando o seguinte comando no diretório do projeto:
1npm install dotenv
Depois de instalado, você pode usar odotenv no início do aplicativo para carregar as variáveis de ambiente:
1require('dotenv').config(); // Loads the environment variables from the .env file
  • Base de conhecimento: é importante uma compreensão básica do JavaScript, Node.js, operações do MongoDB e conceitos fundamentais de aprendizado de máquina.

Configuração do ambiente

Primeiro, vamos configurar adequadamente nosso ambiente de desenvolvimento para garantir uma operação suave e um tratamento eficiente de dados:
Configuração do MongoDB: certifique-se de que o MongoDB esteja instalado e configurado corretamente para armazenar e recuperar seus dados com eficiência. Após a instalação, verifique se o MongoDB está em execução usando o comandomongod, que inicia o servidor MongoDB. Verifique o status do serviço MongoDB para confirmar que ele está ativo, indicando que seu banco de dados está pronto para aceitar conexões.

Node.js setup

Comece criando um novo projeto Node.js:
  1. Inicialize um novo projeto: Abra o terminal, navegue até o diretório do projeto e execute npm init -y para criar um novo arquivopackage.jsonque gerenciará todas as dependências do projeto.
  2. Instale pacotes Node.js: Instale os pacotes Node.js necessários executando npm install mongoose @tensorflow/tfjs-node. Veja o que cada pacote faz:
    • mongooseEsta é uma biblioteca ODM (object data modeling) para MongoDB e Node.js. Essa ferramenta lida com como os dados são interconectados, garante que os dados se ajustem a uma estrutura predefinida e traduz entre os objetos em seu código e sua representação no MongoDB.
    • @tensorflow/tfjs-node: este pacote permite executar modelos TensorFlow com Node.js. Ele fornece o back-end para o TensorFlow.js, que permite executar modelos e processar dados em alta velocidade, diretamente dentro de um ambiente Node.js.
Seguindo estas etapas, você terá um ambiente bem configurado e pronto para desenvolver aplicativos usando o MongoDB e o TensorFlow.js. Essa configuração faz com que todos os componentes sejam instalados e integrados corretamente, permitindo que você se concentre na criação de seu aplicativo sem se preocupar com problemas ambientais.

Gerenciamento de dados

O gerenciamento eficaz de dados no MongoDB é crucial para o aprendizado de máquina:
  • Design de esquema: crie um esquema que reflita a estrutura do seu modelo de dados, otimizando para as operações que você executará com mais frequência. O esquema flexível do MongoDB permite que você adapte sua estrutura de dados aos seus requisitos específicos, o que pode melhorar significativamente o desempenho e a escalabilidade. Para obter uma compreensão mais profunda de como aproveitar efetivamente a flexibilidade de esquema do MongoDB em seus projetos, explore o guia abrangente: Práticas recomendadas de design de esquema do MongoDB. Esse recurso fornece informações valiosas sobre a criação de esquemas de banco de dados eficientes e escaláveis, garantindo que você aproveite ao máximo os recursos do MongoDB.
  • Importação de dados: use o driver Node.js do MongoDB junto com o TensorFlow.js para facilitar o processo de importação de dados que alimenta os modelos de machine learning. Aqui está um detalhamento passo a passo de como escrever scripts que importam seus dados para TensorFlow.js usando um exemplo:
1const mongoose = require('mongoose');
2const tf = require('@tensorflow/tfjs-node');
3
4// Step 1: Connect to MongoDB
5// Replace 'process.env.MONGODB_URI' with your MongoDB connection string.
6mongoose.connect(process.env.MONGODB_URI);
7
8// Step 2: Define a schema and model
9// Create a schema that maps to the structure of the data in your MongoDB.
10const DataSchema = new mongoose.Schema({
11 features: Array, // Array of features for machine learning.
12 labels: Array // Array of labels for each feature set.
13});
14
15// Compile the schema into a model which will give you a class to work with.
16const Dataset = mongoose.model('Dataset', DataSchema);
17
18// Step 3: Fetch data
19// Retrieve data from the MongoDB database using the model.
20Dataset.find().then(data => {
21 // Step 4: Convert the data to tensors
22 // Use TensorFlow.js to convert the array of features into tensors which are
23 // the core data structures used in machine learning models.
24 const tensors = data.map(d => tf.tensor(d.features));
25
26 // Proceed with tensors in TensorFlow.js
27 // You can now use these tensors to train a machine learning model, evaluate it, etc.
28 console.log('Data ready for TensorFlow.js processing:' tensors);
29});
Aqui, orientamos você na conexão ao MongoDB, na definição do esquema de dados e na recuperação dos dados a serem processados com o TensorFlow.js. Veja um detalhamento passo a passo para esclarecer ainda mais esse processo:
  1. Conectar ao MongoDB: primeiro, estabeleça uma conexão com sua instância do MongoDB usando a biblioteca do Mongoose. Isso envolve configurar o URI do banco de dados em suas variáveis de ambiente para acesso seguro.
1 const mongoose = require('mongoose');
2 mongoose.connect(process.env.MONGODB_URI);
2. Definir um esquema e modelo: Defina um esquema Mongoose que corresponda à estrutura dos seus dados. Esse esquema ajuda o MongoDB a entender os dados que armazenará e recuperará. javascript const DataSchema = new mongoose.Schema({ features: Array, // Array of features for machine learning labels: Array // Array of labels for each feature set }); const Dataset = mongoose.model('Dataset', DataSchema);
  1. Obter dados: Use o modelo para obter dados do seu banco de dados. Esses dados serão usados como conjunto de dados para treinar seu modelo do TensorFlow.js. Dataset.find().then(data => { const tensors = data.map(d => tf.tensor(d.features)); console.log('Dados prontos para processamento do TensorFlow.js:', tensors); });
Essas etapas garantem que você não esteja apenas buscando dados, mas especificamente, os dados estruturados e armazenados na configuração do MongoDB, preparando-os para integração com o TensorFlow.js para fins de aprendizado de máquina. Essa configuração detalhada ajuda desenvolvedores iniciantes e experientes a entender o fluxo da recuperação de dados ao treinamento de modelos de aprendizado de máquina em JavaScript.

Explicação detalhada

Etapa 1: Conecte-se ao MongoDB
Estabeleça uma conexão com seu MongoDB database usando Mongoose. Use a função mongoose.connect com o URI do MongoDB armazenado em suas variáveis de ambiente. Essa abordagem mantém as credenciais do seu banco de dados seguras. Normalmente, o URI do MongoDB é armazenado em uma variável de ambiente para evitar a codificação de informações confidenciais em seu código-fonte. Para acessar e usar o URI do MongoDB, você deve primeiro defini-lo em seu arquivo de ambiente (.env) da seguinte forma:
1# .env file
2MONGODB_URI=mongodb+srv://yourusername:yourpassword@yourcluster.mongodb.net/myDatabase
Depois de configurar sua variável de ambiente, você pode acessá-la em seu aplicativo Node.js usando process.env.MONGODB_URI. Certifique-se de que suas variáveis de ambiente sejam carregadas, exigindo o pacote dotenv no início do script:
1require('dotenv').config(); // This line loads the environment variables from the .env file
2mongoose.connect(process.env.MONGODB_URI);
Essa configuração confirma que a string de conexão do seu banco de dados está carregada do seu ambiente, mantendo a segurança e a flexibilidade em diferentes ambientes de sistema.
Etapa 2: definir um esquema e um modelo Defina a estrutura dos seus dados usando esquemas Mongoose para modelar os dados do seu aplicativo. Esse esquema ditará a forma dos documentos que você pode armazenar em uma collection específica.
Etapa 4: Converter dados em tensores Transforme os dados obtidos do MongoDB em tensores, que são matrizes multidimensionais adequadas para entrada em modelos do TensorFlow. Essa conversão é crucial para realizar qualquer tipo de computação de aprendizado de máquina.
Seguindo estas etapas, você pode importar com sucesso seus dados do MongoDB para o TensorFlow.js, preparando-os para tarefas de aprendizado de máquina, como treinamento e predição. Esse processo preenche The Gap entre seu sistema de gerenciamento de banco de dados e os aplicativos deaprendizado de máquina, permitindo o fluxo e a integração de dados contínuos.

Construindo um modelo simples com TensorFlow.js

Vamos construir um modelo preditivo simples adequado para tarefas básicas de aprendizado de máquina. Este modelo foi projetado para demonstrar a natureza direta de definir e treinar uma rede neural usando TensorFlow.js.
Aqui está um exemplo de código com comentários.
1// Initialize a sequential model
2const model = tf.sequential();
3
4// Add a dense layer as the first layer with an input shape required by the model.
5model.add(tf.layers.dense({
6 inputShape: [numFeatures], // Number of features in your input data
7 units: 50, // Number of units in the layer, affects complexity
8 activation: 'relu' // Activation function to introduce non-linearity
9}));
10
11// Add another dense layer, this time to output a single binary value.
12model.add(tf.layers.dense({
13 units: 1, // Only one unit as it's the output layer
14 activation: 'sigmoid' // Sigmoid activation function for binary classification
15}));
16
17// Compile the model with settings for optimization.
18model.compile({
19 optimizer: 'sgd', // Stochastic gradient descent optimizer
20 loss: 'binaryCrossentropy', // Loss function suitable for binary classification
21 metrics: ['accuracy'] // Metric to evaluate during training: accuracy
22});
Resultado esperado: Depois de executar esse bloco de código, não há saída imediata, pois ele está configurando o modelo. O modelo agora está pronto para treinamento com as configurações especificadas.

Treinando o modelo com dados MongoDB

Os dados devem ser pré-processados e normalizados antes de serem inseridos no modelo. Esta etapa garante que o modelo treine em dados dimensionados uniformemente. Iremos treinar o modelo utilizando ostensores preparados a partir de dados MongoDB. Aqui está um exemplo de código com comentários e a saída esperada.
1// Train the model with the tensors data
2model.fit(tensors, labels, {
3 epochs: 10 // Number of iterations over the entire data
4}).then(info => {
5 // Log the final training information
6 console.log('Model trained!', info);
7});
Ao executar este script, você verá uma saída no console semelhante a: Saída no console
Essa saída exibe os resultados do treinamento, mostrando a precisão e a perda após a conclusão do processo de treinamento, indicando o desempenho do modelo. Os valores exatos variarão de acordo com seus dados específicos e condições de treinamento.

Semeando dados

O que é semear?
Semear dados envolve preencher um banco de dados com um conjunto inicial de dados. Isso é particularmente útil durante o desenvolvimento de um aplicativo, onde ter um banco de dados não vazio é crucial para testar e desenvolver recursos que interagem com o banco de dados. A semeação ajuda a simular um ambiente mais realista fornecendo dados que o aplicativo pode recuperar, atualizar ou excluir sem a necessidade de adicionar manualmente os dados de teste.
A semente é importante porque determina se seu aplicativo pode manipular dados predefinidos corretamente. Ele permite que desenvolvedores e testadores prevejam como o aplicativo se comporta com vários conjuntos de dados, identifiquem bugs e melhorem a eficiência da lógica de tratamento de dados. Também é fundamental para ambientes de testes automatizados, onde são necessários estados de dados consistentes para garantir a precisão do teste.
O roteiro fornecido demonstra como popular dados em um banco de MongoDB database usando Mongoose, que é uma biblioteca Node.js que fornece modelagem de objetos MongoDB .
1const mongoose = require('mongoose');
2require('dotenv').config();
3
4// Connect to MongoDB using the connection string from your environment variables
5mongoose.connect(process.env.MONGODB_URI, {
6 useNewUrlParser: true,
7 useUnifiedTopology: true
8});
9
10// Define a schema that describes the structure of the data in your database
11const DataSchema = new mongoose.Schema({
12 features: Array, // Array to store features for machine learning
13 labels: Array // Array to store corresponding labels
14});
15
16// Compile the schema into a model, which is a constructor that you can use for creating documents
17const Dataset = mongoose.model('Dataset', DataSchema);
18
19// Example data to be inserted into the database
20const sampleData = [
21 { features: [0.1, 0.2, 0.3], labels: [1] },
22 { features: [0.4, 0.5, 0.6], labels: [0] },
23 { features: [0.7, 0.8, 0.9], labels: [1] }
24];
25
26// Insert the example data into the database using the model
27Dataset.insertMany(sampleData)
28 .then(() => {
29 console.log('Data seeded successfully');
30 // Properly close the connection to the database
31 mongoose.disconnect();
32 })
33 .catch(err => {
34 console.error('Error seeding data:', err);
35 // Properly close the connection in case of an error as well
36 mongoose.disconnect();
37 });
Principais etapas explicadas:
  1. Conectando-se ao MongoDB: Estabelece uma conexão com o MongoDB usando o URI armazenado em suas variáveis de ambiente, o que garante que dados confidenciais, como credenciais de banco de dados, não sejam codificados em seu aplicativo
  2. Definição de esquema: define como os dados são organizados no banco de dados, o que é fundamental para garantir a integridade dos dados e como eles são acessados e manipulados
  3. Criação de modelo: Compila o esquema em um modelo, que você pode usar para criar, ler, atualizar e excluir documentos em seu banco de dados
  4. Inserção de dados: usa o modelo para inserir uma array de dados predefinidos no banco de dados, o que é crucial para preencher o banco de dados com dados iniciais para fins de desenvolvimento e teste
Esse script normalmente é executado no estágio de desenvolvimento ou ao configurar o ambiente de produção inicialmente. Ele foi projetado para tornar o ciclo de vida de desenvolvimento de aplicativos mais suave e livre de erros, fornecendo um conjunto de dados confiável e consistente para trabalhar.

Como executar o script de sementeira

Primeiro, salve o script de sementeira em um arquivo — por exemplo, seed.js. Em seguida, execute o script usando Node.js executando node seed.js na sua linha de comando.
Este script se conecta ao seu MongoDB database, define o mesmo esquema do seu aplicativo e insere um conjunto de dados de exemplo. Depois que os dados forem semeados, você poderá executar seu script de integração original do TensorFlow.js para treinar e avaliar o modelo usando esses dados. Obtenha a fonte completa e descobre informações detalhadas.

Demonstração da busca de dados e treinamento do modelo com o TensorFlow.js

Etapa 1: Obter dados e convertê-los em tensores Primeiro, vamos recuperar os dados do MongoDB e convertê-los em tensores, que são os componentes principais usados no TensorFlow.js para manipular dados:
1Dataset.find().then(data => {
2 if (data.length === 0) {
3 console.log("No data found in the database.");
4 return;
5 }
6 const features = data.map(d => tf.tensor(d.features));
7 const labels = data.map(d => tf.tensor(d.labels));
8
9 if (features.length === 0 || !features[0]) {
10 console.log("Features array is empty or undefined.");
11 return;
12 }
13});
Usando Mongoose, consultamos todos os documentos no conjunto de dados. Se nenhum dado for encontrado, o processo será interrompido. Os recursos e rótulos de cada elemento são convertidos em tensores para processamento de aprendizado de máquina.
Etapa 2: Crie e compile o modelo Em seguida, defina a arquitetura do seu modelo TensorFlow.js e configure os parâmetros para aprendizado:
1const model = tf.sequential();
2model.add(tf.layers.dense({ inputShape: [features[0].shape[0]], units: 50, activation: 'relu' }));
3model.add(tf.layers.dense({ units: 1, activation: 'sigmoid' }));
4model.compile({ optimizer: 'sgd', loss: 'binaryCrossentropy', metrics: ['accuracy'] });
Um modelo sequencial é adequado para uma pilha de camadas em que cada camada tem exatamente um rígidor de entrada e um nó de saída. Essas camadas estão totalmente conectadas e são usadas para prever a saída a partir dos recursos de entrada. O modelo é preparado para treinamento definindo um otimizador, uma função de perda e métricas para avaliação de desempenho.
Etapa 3: preparar os dados e treinar o modelo Agora, prepare seus dados para o treinamento e inicie o processo de treinamento:
1const xs = tf.stack(features);
2const ys = tf.stack(labels);
3
4model.fit(xs, ys, {
5 epochs: 10,
6 callbacks: {
7 onEpochEnd: (epoch, logs) => console.log(`Epoch ${epoch}: loss = ${logs.loss}, accuracy = ${logs.acc}`)
8 }
9});
Os recursos e rótulos são empilhados em tensores para corresponder aos requisitos de entrada do modelo do TensorFlow. O modelo aprende com os dados em um número específico de épocas, ajustando seus pesos para minimizar a perda e melhorar a precisão.
Etapa 4: Avalie o modelo Por fim, avalie o modelo para entender sua eficácia:
1async function evaluateModel(model, xs, ys) {
2 const evalResult = model.evaluate(xs, ys);
3 const loss = await evalResult[0].data();
4 const accuracy = await evalResult[1].data();
5 console.log(`Evaluation Results - Loss: ${loss}, Accuracy: ${accuracy}`);
6}
7evaluateModel(model, xs, ys);
Esta etapa avalia o desempenho do modelo nos mesmos dados, fornecendo métricas como perda e precisão para avaliar seus recursos de previsão.
Essa abordagem permite que você utilize o JavaScript em toda a pilha para o tratamento de dados com o MongoDB e o aprendizado de máquina com o TensorFlow.js, simplificando o desenvolvimento de aplicativos baseados na web.

Avaliar e melhorar o modelo

Avaliar seu modelo é crucial para entender quão bem ele prenuncia ou classifica dados novos e não vistos. Esta etapa envolve o uso de um conjunto de dados de teste não usado durante a fase de treinamento. Para facilitar isso, você pode escolher entre vários conjuntos de dados de teste disponíveis online. Aqui estão algumas fontes onde você pode encontrar conjuntos de dados que se adequam às características dos seus dados:
  1. UCI Machine Learning Repository — uma collection de bancos de dados, teorias de domínio e geradores de dados amplamente usados pela comunidade de aprendizado de máquina
  2. Conjuntos de dados Kaggle — oferece uma gama diversificada de conjuntos de dados fornecidos pela comunidade Kaggle, que podem ser úteis para praticar e aplicar técnicas de aprendizado de máquina
  3. Google Dataset Search — uma ferramenta que permite descobrir conjuntos de dados armazenados na Web, selecionados e indexados para uso público
Veja como proceder com sua avaliação.
Etapa 1: Preparar um conjunto de dados de teste Certifique-se de ter um conjunto de dados separado reservado para teste. Esse conjunto de dados deve espelhar a estrutura de seus dados de treinamento, mas incluir instâncias diferentes para avaliar a capacidade de generalização do modelo de forma eficaz.
1// Assuming testFeatures and testLabels are prepared similarly to training data
2const testFeatures = tf.tensor(testData.map(d => d.features));
3const testLabels = tf.tensor(testSubData.map(d => d.labels));
Etapa 2: Avalie o modelo
Use o métodoevaluatede seu modelo do TensorFlow.js para avaliar seu desempenho no conjunto de dados de teste. Essa função retorna o valor da perda e as métricas que foram definidas durante a compilação do modelo.
O valor de perda é uma representação numérica de quão bem as projeções do modelo correspondem aos valores de alvo reais. Quanto menor a perda, melhores são as projeções de um modelo. Ele serve como uma medida primária a ser otimizada durante o processo de treinamento por meio da backpropagation. A função de perda escolhida depende da natureza do seu problema (por exemplo, entrada cruzada binária para classificação binária, erro médio quadrático para regressão).
Durante a compilação do modelo com TensorFlow.js, você especifica a função de perda que será usada para calcular esse valor, juntamente com quaisquer métricas adicionais (como precisão) que ajudem a avaliar ainda mais o desempenho do modelo.
Veja como você pode executar esta avaliação:
1const evaluationResults = model.evaluate(testCoupleFeatures, testLabels);
2evaluationResults.forEach((result, index) => {
3 console.log(`Metric ${model.metricsNames[index]}: ${result.dataSync()}`);
4});
Neste trecho de código:
  • model.evaluate(testFeatures, testLabels) invoca o processo de avaliação em que testFeatures são os dados de entrada e testLabels são os valores verdadeiros para essas entradas.
  • A arrayevaluationResults contém a perda primeiro, seguida por quaisquer outras métricas especificadas durante a compilação. Para cada métrica, incluindo a perda, o resultado pode ser acessado e exibido.
  • result.dataSync() é usado para recuperar a saída do formato tensor do TensorFlow para números legíveis em JavaScript.
Esse método de avaliação ajuda a verificar a eficiência da generalização do modelo para novos dados, com base na função e nas métricas de perda predefinidas.
Selecione um conjunto de dados de teste nos links fornecidos que melhor atenda às necessidades do seu modelo e prossiga com a avaliação para avaliar o desempenho do seu modelo TensorFlow.js de forma eficaz.

Melhoria: experimente arquiteturas de modelos e configurações de treinamento

Melhorar seu modelo envolve ajustar vários aspectos de sua arquitetura e configuração de treinamento para obter melhor precisão e eficiência. Veja como você pode experimentar:
Etapa 1: Ajustar aarquitetura do modelo A modificação da arquitetura do modelo pode levar a melhorias significativas. Você pode adicionar mais camadas, aumentar o número de unidades nas camadas existentes ou alterar as funções de ativação para aprimorar a dinâmica de aprendizado.
1model.add(tf.layers.dense({units: 100, activation: 'relu'})); // Adding a more complex layer
2model.add(tf.layers.dropout({rate: 0.5})); // Including dropout for regularization
Etapa 2: Faça experiências com diferentes otimizadores e taxas de aprendizagem Diferentes otimizadores e taxas de aprendizagem podem afetar a velocidade e a qualidade do processo de aprendizagem. Experimentar diferentes combinações pode ajudá-lo a encontrar a configuração ideal para seu problema específico.
1model.compile({
2 optimizer: tf.train.adam({learningRate: 0.01}), // Using Adam optimizer with a higher learning rate
3 loss: 'binaryCrossentropy',
4 metrics: ['accuracy']
5});
Etapa 3: Treinamento com modificações Depois de fazer os ajustes, retreine seu modelo para ver os efeitos das alterações. É importante monitorar o processo de treinamento e os resultados de validação para evitar o sobreajuste.
1model.fit(trainFeatures, trainLabels, {
2 epochs: 20,
3 validationData: [testFeatures, testLabels],
4 callbacks: tf.callbacks.earlyStopping({monitor: 'val_loss'})
5});
Para entender claramente o impacto de suas modificações, compare as métricas de desempenho antes e depois das melhorias. Essa comparação pode ser registrada ou visualizada para mostrar o progresso e confirmar os benefícios das alterações.
1console.log('Before Improvement:', previousEvaluationResults);
2console.log('After Improvement:', newEvaluationResults);
Ao estruturar o processo de teste e melhoria dessa maneira, você não apenas garante que seu modelo seja robusto e generalize bem, mas também otimiza seu desempenho para atender às necessidades específicas de seu aplicativo. Essa abordagem iterativa de desenvolvimento e avaliação permite um ajuste de modelo mais eficiente e, em última análise, um desempenho preditivo mais preciso.

Conclusão

A integração do MongoDB com o TensorFlow.js abre uma inumeração de possibilidades para criar e implantar aplicativos baseados em machine learning em JavaScript. Este guia serve como ponto de partida para inspirá-lo a explorar ainda mais essa empolgante interseção entre o desenvolvimento da Web e o aprendizado de máquina.

Apêndice

Para aprender mais, consulte a documentação doTensorFlow.js e doMongoDBe confira osmodelos de machine learning e as operações de banco de dados mais complexos. Se você tiver dúvidas ou quiser compartilhar seu trabalho, junta-se a nós na Comunidade de desenvolvedores do MongoDB.
Obrigado por ler... Feliz codificação!
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.
Iniciar a conversa

Ícone do FacebookÍcone do Twitterícone do linkedin
Avalie esse Tutorial
star-empty
star-empty
star-empty
star-empty
star-empty
Relacionado
Notícias e anúncios

Laravel Herd adiciona suporte nativo ao MongoDB


Oct 07, 2024 | 0 min read
Artigo

Como a Queryable Encryption pode manter o James Bond seguro


Apr 02, 2024 | 2 min read
Podcast

Tornando os dados sobre diabetes mais acessíveis e significativos com o Tidepool e o MongoDB


Aug 14, 2024 | 15 min
Artigo

Lidando com Erros do MongoDB PHP


Aug 28, 2024 | 7 min read
Sumário