A Beginner's Guide to Integrating MongoDB With TensorFlow Using JavaScript

1
npm install dotenv

1
require('dotenv').config(); // Loads the environment variables from the .env file

1
const mongoose = require('mongoose');
2
const tf = require('@tensorflow/tfjs-node');
3
4
// Step 1: Connect to MongoDB
5
// Replace 'process.env.MONGODB_URI' with your MongoDB connection string.
6
mongoose.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.
10
const 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.
16
const Dataset = mongoose.model('Dataset', DataSchema);
17
18
// Step 3: Fetch data
19
// Retrieve data from the MongoDB database using the model.
20
Dataset.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
});

1
 const mongoose = require('mongoose');
2
 mongoose.connect(process.env.MONGODB_URI);

1
# .env file
2
MONGODB_URI=mongodb+srv://yourusername:yourpassword@yourcluster.mongodb.net/myDatabase

1
require('dotenv').config();  // This line loads the environment variables from the .env file
2
mongoose.connect(process.env.MONGODB_URI);

1
// Initialize a sequential model
2
const model = tf.sequential();
3
4
// Add a dense layer as the first layer with an input shape required by the model.
5
model.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.
12
model.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.
18
model.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
});

1
// Train the model with the tensors data
2
model.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
});

1
const mongoose = require('mongoose');
2
require('dotenv').config();
3
4
// Connect to MongoDB using the connection string from your environment variables
5
mongoose.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
11
const 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
17
const Dataset = mongoose.model('Dataset', DataSchema);
18
19
// Example data to be inserted into the database
20
const 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
27
Dataset.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
    });

1
Dataset.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
});

1
const model = tf.sequential();
2
model.add(tf.layers.dense({ inputShape: [features[0].shape[0]], units: 50, activation: 'relu' }));
3
model.add(tf.layers.dense({ units: 1, activation: 'sigmoid' }));
4
model.compile({ optimizer: 'sgd', loss: 'binaryCrossentropy', metrics: ['accuracy'] });

1
const xs = tf.stack(features);
2
const ys = tf.stack(labels);
3
4
model.fit(xs, ys, {
5
    epochs: 10,
6
    callbacks: {
7
        onEpochEnd: (epoch, logs) => console.log(`Epoch ${epoch}: loss = ${logs.loss}, accuracy = ${logs.acc}`)
8
    }
9
});

1
async 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
}
7
evaluateModel(model, xs, ys);

1
// Assuming testFeatures and testLabels are prepared similarly to training data
2
const testFeatures = tf.tensor(testData.map(d => d.features));
3
const testLabels = tf.tensor(testSubData.map(d => d.labels));

1
const evaluationResults = model.evaluate(testCoupleFeatures, testLabels);
2
evaluationResults.forEach((result, index) => {
3
    console.log(`Metric ${model.metricsNames[index]}: ${result.dataSync()}`);
4
});

1
model.add(tf.layers.dense({units: 100, activation: 'relu'})); // Adding a more complex layer
2
model.add(tf.layers.dropout({rate: 0.5})); // Including dropout for regularization

1
model.compile({
2
    optimizer: tf.train.adam({learningRate: 0.01}), // Using Adam optimizer with a higher learning rate
3
    loss: 'binaryCrossentropy',
4
    metrics: ['accuracy']
5
});

1
model.fit(trainFeatures, trainLabels, {
2
    epochs: 20,
3
    validationData: [testFeatures, testLabels],
4
    callbacks: tf.callbacks.earlyStopping({monitor: 'val_loss'})
5
});

1
console.log('Before Improvement:', previousEvaluationResults);
2
console.log('After Improvement:', newEvaluationResults);