DEV Community: Matias Vazquez-Levi

Automating Code Comments with GPTDoc: A Step-by-Step Guide

Matias Vazquez-Levi — Tue, 06 Jun 2023 19:05:41 +0000

As developers, we are always looking for ways to improve the efficiency of our workflow while maintaining the quality of our code. One essential aspect of any well-organized codebase is its documentation. Good documentation ensures that the intent and purpose of the code are well understood by both present team members and future maintainers of the codebase.

However, writing comprehensive and accurate documentation is a time-consuming process. What if we could automate the process of generating code comments for our functions? This is where GPTDoc comes in. GPTDoc is a code comment generator tool that leverages OpenAI models to generate documentation for your code automatically.

Requirements

Node >=18.0.0
npm >=8.0.0

Using

gptdoc

Getting Started with GPTDoc

Install gptdoc as a dev dependency in the project you want to document

Installing

npm i --save-dev gptdoc

Configuring

Create a configuration file named .gptdoc in the root of your project

{
    "DEBUG": false,
    "framework": "JSDOC",
    "language": "JS",
    "files": {
        "src": "./src",
        "dest": "./gpt",
        "recursive": true
    },
    "openai": {
        "temperature": 0.7,
        "top_p": 1,
        "max_tokens": 256,
        "model": "text-davinci-003"
    },
    "prompt": "Add property tags with @prop"
}

Change the src directory to your directory holding your project's source code.

OpenAI API Key

You need to have access to OpenAI's private beta API, and provide a token.

Create a file named .env in the root of your project

OPENAI_API_KEY="your-key-here"

You can find your token here

Auto-Document

Every method or class with a /** @gpt */ code comment will be documented

/** @gpt */
function foo(x) {
    let sum = 0;
    for (let i = 0; i < x.length; i++) {
        sum += x[i];
    }
    return sum;
}

Run the script to document

node node_modules/gptdoc

If everything was configured properly, you should see a copy of your codebase in ./gpt which holds all the documentation comments

Here is an example of the output

/**
 * @autogenerated
 * @description Calculate the sum of all elements in an array.
 * @function foo
 * @param {number[]} x - An array of numbers to sum up.
 * @returns {number} The sum of all elements in the input array.
 */
function foo(x) {
    let sum = 0;
    for (let i = 0; i < x.length; i++) {
        sum += x[i];
    }
    return sum;
}

We learned how to automate the generation of code comments using GPTDoc. By following these steps, you can save valuable time in maintaining your codebase and focus on other important tasks in your project. Don't forget to always review the autogenerated comments to ensure their accuracy and to maintain a high level of quality in your documentation. Keep a Human in the loop!

Train a Deep Neural Network to recognize handwritten digits with Dannjs.

Matias Vazquez-Levi — Fri, 13 Aug 2021 15:07:00 +0000

A famous task performed by Deep models is handwritten digit recognition.
Here is how you can create your model & train it with some images of digits.

Requirements

Nodejs
Some knowledge about neural networks

Using

easy-mnist
Dannjs
fs (optional)

MNIST

We're going to use a dataset called MNIST. You can read more about it here.

MNIST is a dataset containing a total of 70 000 28x28 images of handwritten digits.

It contains an image and a label in order to identify the digit.

MNIST to a Deep Model

To show these images to our Deep model, we're going to need to feed every pixel with values ranging in-between 0 and 1. A 0 would represent a black pixel and a 1 would represent a white pixel.

The image below demonstrates this very well.

We could see a 28 by 28 image as an array of 784 values. This is how we are going to feed the images to our neural network.

When feeding our model with image data, we also need to give the desired output in order to train it. In the image above, the neuron labeled 6 is circled to demonstrate this.

Now that we understand how we are going to train our MNIST model, let's get started!

Project setup

Start by initiating an npm project with

npm init -y

In order to access the dataset, install the MNIST npm package

npm i easy-mnist

We are also going to install our Neural Network library, Dannjs.

npm i dannjs

Import the dataset

In our index.js file, were going to require the dataset. We are creating a training set of 60 000 images and a testing set of 10 000 images.

const dataset = require('easy-mnist').makeData(60000,10000);

This is going to create two sets, the training set & the testing set.

Luckily, our dataset of images already comes in 784-length array format and the labels come as a 10-length array.
We can access those like so

// For the training set
dataset.traindata[index].image
dataset.traindata[index].label

// For the testing set
dataset.testdata[index].image
dataset.testdata[index].label

Creating our Model

We first need to create a model, for this, we are going to import dannjs

const Dann = require('dannjs').dann;

We can then create a Dann model with 784 inputs and 10 outputs. We're also going to add two hidden neuron layers with leakyReLU activations and then set the learning rate to 0.0001.

const nn = new Dann(784, 10);
nn.addHiddenLayer(128 ,'leakyReLU');
nn.addHiddenLayer(64 ,'leakyReLU');
nn.makeWeights();
nn.lr = 0.0001;

We can then log the model to confirm the model creation was successful

nn.log();

Training the model

For our model to be trained, we need to iterate through the whole training set. Having completed the entirety of the training set is what we call an epoch. In order to successfully train a model, we need multiple epochs.

This is what 1 epoch looks like

for (let i = 0; i < dataset.traindata.length; i++) {
    nn.train(dataset.traindata[i].image, dataset.traindata[i].label);
}

We can then loop multiple epochs

let epochs = 10;
for (let e = 0; e < epochs; e++) {
    for (let i = 0; i < dataset.traindata.length; i++) {
        nn.train(dataset.traindata[i].image, dataset.traindata[i].label);
    }
    console.log("Completed epoch " + e + " with a loss of " + nn.loss);
}

With 10 epochs, depending on the model you created & your CPU's performance, it might take a few minutes. 10 epochs might not even be enough to train a very accurate model.

Around 100 epochs, your model might reach an acceptable level of accuracy.

The number of epochs & training time all depend on a lot of factors about the model. Experiment with the creation of a neural network, try adding one more layer, changing activation functions, or changing the learning rate, and see what happens.

Since it might take a while to train, it is a good idea to save a model in order to keep training progress.
Here is how you can do so using fs, (do not forget to install it with npm i fs).

Import fs

const fs = require('fs');

Saving our model to myModel.json

let json = JSON.stringify(nn.toJSON());
fs.writeFileSync('myModel.json', json, 'utf-8');

Loading back our model from myModel.json

let data = fs.readFileSync('myModel.json', 'utf-8');
let model = JSON.parse(data);
const nn = Dann.createFromJSON(model);

So there you have it! How to train an MNIST model with Dannjs.

We are hosting a MNIST model contest, the most accurate model wins!
You can submit your model here & try it out live.
Results are posted in our discord server here is the invite link

Use a Neural Network without its library

Matias Vazquez-Levi — Thu, 03 Jun 2021 13:59:26 +0000

Various web applications use Neural Networks. The only downside is that you need to import an entire library to run these types of algorithms, which might be inconvenient.

Hopefully, the Dannjs library has a way of saving a Neural Network as a standalone JS function, which allows you to get the predictions without including the whole library.

In this short tutorial, we're going to train an XOR neural network in the new Online editor, and then use it in another browser without importing the library.

Here are the requirements for this tutorial:

Dannjs Online Editor
Any web browser

Setup

Let's start by creating the Neural Network.

const nn = new Dann(2, 1);
nn.addHiddenLayer(8, 'leakyReLU');
nn.makeWeights();
nn.lr = 0.1;

Training

We can train the neural network with the XOR logic, 1000 epochs should do the trick.

let epochs = 1000;
for (let i = 0; i < epochs; i++) {
    nn.backpropagate([0,1],[1]);
    nn.backpropagate([1,0],[1]);
    nn.backpropagate([0,0],[0]);
    nn.backpropagate([1,1],[0]);
}

Testing

Once trained, we can test the output

nn.feedForward([0,1],{log:true});
nn.feedForward([1,0],{log:true});
nn.feedForward([0,0],{log:true});
nn.feedForward([1,1],{log:true});

This should result in accurate predictions

Prediction:
[0.9955815601552473]

Prediction:
[0.9954508755506862]

Prediction:
[0.04536960523468736]

Prediction:
[0.003240998243744729]

Save

We can finally save the Neural Network as a minified function as a string that we can copy & use anywhere else.

let func = nn.toFunction();
console.log(func);

Here is how you would use the function in another JS environment such as the chrome console.

We can see that we get the same predictions because every single parameter has been saved into the function.

This feature allows us to use any neural network outside of the library, making the usage of these algorithms in web applications simple & lightweight. Loading times on web pages is always a good thing to look out for, making this a neat trick to know about!

Train a Neural Network to Count, with Javascript & Dannjs

Matias Vazquez-Levi — Thu, 14 Jan 2021 15:38:08 +0000

Counting is pretty intuitive for us humans, not as much for neural networks. This is why you are here, learning to build your first neural network with Dannjs. Using some machine learning concepts, we are going to build a neural network in JavaScript that learns to count number after number. Dannjs is a new open-source library that allows for the simple implementation of neural networks in your projects.

Making a neural network yourself is a good way to familiarise yourself with the concept itself. This is also relatively simple to do. The library we will use, Dannjs, makes it even easier to have clean and simple code.

Prerequisites:

Nodejs
Dannjs
Some abstract knowledge about Neural Networks

Let’s understand the basics of binary numbers first.

To teach our Neural Network to count, we will translate our well-known integers into binary data (4-bits). Each bit is going to correspond to one input/output neuron in the neural network.

Ideally, we want to train our network to output the next number we feed it. For example, If we feed the network [0,0,0,1] we want it to output [0,0,1,0]. Since there are only 4 spaces for boolean information, our model will only count up to 15, which is equal to 1111 in binary. You could try adding more inputs and outputs to your model. In this case, your dataset would have to be bigger to accommodate 5 bits of information.

Project Setup

First off, we’re going to install Dannjs locally in our project directory.

npm i dannjs

We would now need to require the node module we installed in our main js file.

const Dannjs = require('dannjs');
const Dann = Dannjs.dann;

Creating the Neural Network

This is how we would create the neural network. We are giving it 4 input neurons for the 4 bits of binary data to input. We are also going to give it 4 output neurons for the 4 bits of binary data the model is going to have to output.

const countingNN = new Dann(4,4);

We now need to add some hidden layers. I’ve found that 16 neurons worked well enough. You could experiment with this value later. A hidden layer is basically a neuron layer that can perform computations. The name ‘hidden’ comes from the fact that you do not need to see the values of each neuron, unlike the input/output layers. You can learn more about hidden layers & the basics surrounding it here. We are also going to set the activation function to 'leakyReLU' , activation functions are also explained in the link above.

const countingNN = new Dann(4,4);
countingNN.addHiddenLayer(16,'leakyReLU');
countingNN.lr = 0.01;

Technically, we have finished the creation of our model by now. We could test it right away with the Dann.log(); command or by feeding the model some 4-bit data.

countingNN.log();
countingNN.feedForward([0,0,1,0],{log:true});

The log function displays information about the model we just created. We also specify in the feedForward options that we want to log the predictions of the model.

Dann NeuralNetwork:
  Layers:
    Input Layer:   4
    hidden Layer: 16  (leakyReLU)
    output Layer: 4  (sigmoid)
  Other Values:
    Learning rate: 0.01
    Loss Function: mse
    Latest Loss: 0

Prediction:  [0.5398676880698,0.6730987170697,0.6748741672290,0.6377646387674]

We can see that this gives us some random predictions. Obviously, this was going to happen because we never trained the model… In order to train our model, we need some sort of dataset telling the neural network what to output according to what input is given.

Setting up the Dataset

To train the model, we’re going to need a dataset. Here is a lightweight js dataset for 4-bits binary counting. It basically looks like this:

const dataset4bit = [

    //...
    {
        input:[1,0,1,0],
        target:[1,0,1,1]
    },
    //  {
    //      input:[1,0,1,1],
    //      target:[1,1,0,0]
    //  },
    {
        input:[1,1,0,0],
        target:[1,1,0,1]
    },

    //...
];

You can access the dataset here

We can see that this dataset contains one number x in 4-bit binary, as the input value and the number x+1 in 4-bit binary as the target value. I commented out the element [1,0,1,1] so we can have a test sample the neural network has never seen. To access the data, we can copy the code included in the GitHub gist above and save it in binaryCountData.js in the same directory as our project. We can then require the file:

const dataset = require('./binaryCountData.js').dataset;

We can now access the data this way:

dataset[i].input
dataset[i].target

Now that we have access to the dataset let’s apply it by calling Dann.backpropagate(); for each data point in our dataset array. This will tune the weights of the model according to the data you give it.

for (data of dataset) {
    countingNN.backpropagate(data.input,data.target);
}

This counts as 1 epoch. We iterated through every element in our dataset once. Sadly, 1 epoch is not enough for a Neural Network to train properly. We would need to perform multiple epochs in order to achieve satisfying results. Let's also add a Dann.feedForward(); to test what the model outputs after training.

const epoch = 100000;
for (let e=0; e < epoch;e++) {
    for (data of dataset) {
        countingNN.backpropagate(data.input,data.target);
    }
}

countingNN.feedForward([1,0,1,1],{log:true});

And after training 100 000 epochs, it outputs:

Prediction:  [0.999884854,0.9699951248,0.020084607062,0.008207215405]

We made it! We can see that it guesses pretty close to [1,1,0,0], which is a good answer.
This is what the final js code should look like:

const Dannjs = require('dannjs');
const Dann = Dannjs.dann;
const dataset = require('./binaryCountData.js').dataset4bit;

const countingNN = new Dann(4,4);
countingNN.addHiddenLayer(16,'leakyReLU');

countingNN.lr = 0.01;

countingNN.feedForward([1,0,1,1],{log:true});
const epoch = 100000;
for (let e=0; e < epoch;e++) {
    for (data of dataset) {
        countingNN.backpropagate(data.input,data.target);
    }
}
countingNN.feedForward([1,0,1,1],{log:true});

In this tutorial, we trained a neural network to count binary integers. We learned how binary numbers worked in order to digitalize them into our neural network. We then learned how to use Dannjs, the new neural network library that just came out, without any prerequisite ML knowledge. Feel free to tweak all the settings you want, experiment, play around, you’ll eventually get a grasp of what affects what. The only source of knowledge is experience.

daily.dev delivers the best programming news every new tab. We will rank hundreds of qualified sources for you so that you can hack the future.