DEV Community: Jaydeep Borkar

COVID Letters: Spreading positivity in the age of COVID

Jaydeep Borkar — Mon, 11 May 2020 16:56:21 +0000

My friend @santoshvijapure and I very recently built a platform called COVID Letters where every one of us can write anonymous letters to spread positivity and help others combat anxiety and loneliness during this pandemic. A lot of people around were struggling with their mental health due to social isolation. This inspired us to build something to spread love and hope amidst this challenging time.

Tech Stack: Bootstrap, Nodejs, MongoDB.

We have just open-sourced the platform. Here is the GitHub repository. Would love to know everyone's thoughts and feedback on this.

Building a Chatbot using Dialogflow on Google Assistant for Beginners

Jaydeep Borkar — Thu, 30 May 2019 22:31:09 +0000

In this tutorial, we will learn to build a chatbot (a virtual assistant) using Dialogflow which will work on Google Assistant.

But what is Dialogflow in the first place?
It’s a tool by Google to build conversational chatbots.

STEPS
1) Go to the Dialogflow Console -- you will see a Dialogflow home page.
2) Sign in using your Google account.
3) After you sign in, click on Go to console.
You will be directed to the main console of Dialogflow. Now click on the drop-down icon next to the settings icon in the left-most column, and then click on create new agent.

Now, what is an agent over here?
Agent is an interface in Dialogflow which contains different sections called intents which further contain all the responses to the user’s queries. We will learn more about intents as we proceed ahead.

Creating a new agent
After you click on create new agent, give an agent name, default language, time zone, and click on create. Keep create a new Google project as it is in the Google project section. It will create a new Google project for Actions on Google and Google Cloud. We will be integrating Dialogflow with Actions on Google console which would help us to deploy it on Google Assistant.
Now, you can see your created agent in the console. We will be creating different intents now for our agent. You can create as many intents as you want. Two default intents -- Fallback and Welcome are already created.

Let’s understand the Default Fallback and Welcome intent
Fallback intent comes into picture when the bot won’t understand the query triggered/asked by the user. It means there is no intent that matches the query asked by the user. It will give a response like sorry, I didn’t get it. Talking practically -- whenever you say something very unusual to Google Assistant, it will say sorry, didn’t get you. Here, after you said something strange that’s not a natural language, the Fallback intent got triggered and gave this response.

Default Welcome intent will greet the user once your bot is called. You can customize both the default intents with the responses that you want.

Now click on the + sign to create more intents. You can make as many intents as you want, depending on your use-case. Let’s say you are building a chatbot for an ice cream parlor, and the user wants to know all the flavors that you serve. Here, you will create an intent let’s say flavors. Then you will add the training phases.

Training Phrases
Training phases are the queries that the user will ask to your chatbot. You can add as many similar training phrases as you want. These are the queries that you think the user would most likely ask. For the flavor intent, you can add training phrases like -- What flavors do you have?, Show me the flavors, Flavours, I want to have a look at the flavors, and the list is endless. These training phrases are used to train a natural language understanding model internally. This is the best part about
Dialogflow, you don’t have to write any code to train the model. In circumstances, where you want real-time results, you can write some Node.js code which we will talk later about!

The Response section in the Intent
Now, in the Responses section, you can add the responses that you would like to show to the users. For instance, a simple response to a question in the training phrase -- Show me the flavors could be Mango, Vanilla, Chocolate. Make sure you append every response for every intent that you create with the sentence would you like to know anything else?, because for every intent except the exit intent (the intent that you would use when the user exits) it’s necessary that your response has a user prompt, else it would be against the guidelines published by Google and your app might not get published.

In a similar fashion, you can have as many intents as you like, as per your need.

Don’t forget to save every time you make an intent.

Making an Exit Intent
You also need to make an intent that would get triggered while the user leaves your app, which we would call as exit intent. For instance, if the user says, bye, you can have a separate intent for this with the training phrases related to bye, and in the response section, you can add anything that you like or something like feel free to visit again. Don't forget to toggle on set this intent as the end of the conversation at the bottom of this intent, as this intent will mark the end of the conversation with the user.

Using Node.js Code
Now, if you want to give some real-time output to your users, then you can write some Node.js code for the same. Go to the Fulfillment section at the left of the console, there you will see an option for Inline editor, toggle it on to enable it. You can write your code in index.js part. Let’s say, you’re making an app for a restaurant. The restaurant’s working hours are from 10:00 am - 10:00 pm, now if someone wants to check at 11:00 pm if the restaurant is open or not, instead of giving the static response like “Our timings are from 10:00 am - 10:00 pm”, the code will take the real-time parameters and will tell if the restaurant is open at that specific time or not. You can use Node.js code for different use cases, this is just an example. After you’re done, click on deploy.

Integrations
You can have your chatbot integrated with different platforms like -- Slack, Facebook Messenger, Alexa, Cortana, Twitter, Viber, Skype, Telegram, and many others. Make sure to toggle on the platforms that you like. We will be sticking to the Google Assistant, which is the default one.

History
In the History section on the console, you can check how the users are interacting with your app and what all are they saying. You can use this as a tool to check what specific questions is your app unable to answer so that you can work on them.

Analytics
In the Analytics section, you would see the analysis of how your app is performing.
Now it’s time to test the app. Let’s see how it works.

Testing the App
On the Dialogflow console, at the right side, you would see See how it works on Google Assistant, click on that. Once you click it, you will see the test simulator. Let’s say that our app name is test app, then you will see the invocation phrase something along the line Talk to my test app on the simulator. You can test your app with all the training phrases/questions that you have used to train the model. You will get a better intuition about how your app will actually perform once it gets deployed on the assistant.
Now, it’s time to deploy it.

Deploying
On the simulator page itself, you will see an overview section at the left. Click on that. In the Quick setup part, you can choose how your action should be invoked. In the Get ready for deployment part, you can choose what countries would you like to provide your app over Assistant. By default, it’s all 215 countries. You can also choose what surfaces would you like to run your app over, it’s both phones and speakers by default.

Now, go to the Deploy section, go to Directory information -- here you can add a short and long description for your app, sample invocations, background and profile image for your app, contact information, and privacy and consent. These all will be visible to your users. Feel free to click on Need help creating a Privacy Policy? to know how to make a privacy policy, please follow all the steps over there. You can various free tools to make a privacy policy for your app. Then you can choose what category your app belongs to and some other related information about your app below it. After you’re done with all these, click SAVE at the top.

Afterward, you can add Surface Capabilities and Company details in the Deploy section itself. After that, go to the release section within the deploy section itself -- there you would see an option to submit for production in the production part. Click on that and your app will be submitted for the review by Google. If it meets all the guidelines, it will be soon deployed on Google Assistant within 24-48 hours (you will receive an email from Google once it gets deployed successfully; and if it doesn’t, you will get an email in this case as well with all the errors so that you can fix them and submit for the production again). You can also opt for the alpha and beta versions for your app.

Once it’s deployed, your app will be available to over 500+ million devices without any installation, isn’t that cool?

Feel free to post any doubts or suggestions!

Friendly Introduction to Machine Learning and Decision Trees

Jaydeep Borkar — Fri, 03 May 2019 14:39:35 +0000

At an atomic level, Machine Learning is about predicting the future based on the past. For instance, you may wish to predict which team will win the upcoming Cricket World Cup. You will need to consider various factors for doing the prediction, like: type of pitch, weather conditions, number of spin bowlers, strike rate, the record of the team in the last five matches, etc. In a nutshell, a model will make predictions on unseen data by learning from the past data.

Now, what does learning actually means? What does it mean when we say that the model should learn well?

Let’s take this example:

John is taking a course on Linear Algebra, and at the end of the course, he is expected to take a exam to understand if he has “learned” the topic properly or not. If he scores well in the exam, it means that he has learned well. And if he fails, he hasn’t learned the topic properly.

But what makes a reasonable exam? If the questions in a linear algebra exam are based on Chemistry, then the exam won’t tell how well John has learned linear algebra, and if every question in the exam comes from the examples which John went through during his linear algebra classes, then it’s a bad test of John’s learning. Thus, in order to make a reasonable test, the questions should be new but related to the examples covered in the course. This tests if John has the ability to generalize. Generalization is perhaps a very important part of Machine Learning.

Let’s take the example of a course recommendation system for computer science students. It will predict how much a specific student will like a particular course. A student has been given a subset of courses and has evaluated the previously taken courses from them by giving them a rating from -2 (worst) to +2 (excellent). The job of the recommender system is to predict how much a particular student (say, John) will like a particular course (say, Deep Learning).

Now we can be unfair to this system: let’s say we ask the system to predict how much John will like a course on Energy Sciences. This is unfair because the system has no idea what Energy Sciences even is, and has no prior experience with this course. On the other hand, we could ask how much John liked the Natural Language Processing course which he took last year and rated +2 (excellent for it). In this case, the system will tell us that John will like this course, but it’s not the real test of the model’s learning since it’s just recalling it’s past experience. In the former case, we are expecting the system to generalize beyond its experiences, which is unfair. In the latter case, we are not expecting it to generalize at all.

The objects that our model will be making predictions about are called examples. In the recommender system, the example would be a Student/Course pair and the prediction would be the rating. We are given training data on which our algorithm is expected to learn. This training data is the historical rating data for the recommender system which it will use to make predictions for the test data. The system will create an inductive function f from this training data that will map the new example to the corresponding prediction. The function will take two parameters (Student, Course).

Function f (John/Machine Learning) would predict that John will like Machine Learning since the model knows that he took Natural Language Processing course in the past, which he liked. This is the art of inducing intelligence in the model. Thus, the system shows generalization. The data on which the system will make predictions is called as a test set. The test set should always be a secret. If the model gets to peek at it ahead of the time, it’s going to cheat and do better than it should.

The Decision Tree Model of Learning

The Decision Tree is a very classic model of learning which works on the “divide and conquer” strategy. Decision Trees can be applied to various learning problems like regression, binary and multiclass classification, Ranking, etc. We would consider binary classification in our case.

Suppose your goal is to predict if some unknown student will enjoy some unknown course. The output should be simply “yes” or “no”. You are allowed to ask as many binary questions as you can to get the output.

Consider this example:

You: Is the course under consideration in AI?
Ans: Yes

You: Has the student previously taken any AI courses?
Ans: Yes

You: Has the student liked previous courses in AI?
Ans: Yes

You: Does the student wants to make a career in AI?
Ans: Yes

You: I predict this student will like AI course.

Based on these binary questions, we will generate a decision tree.

How to check how well a model has performed?

To check how accurate the model’s performance is, we make a function for it, which we usually refer to as a loss function l(y, y’). Different learning problems have different forms of loss function. For regression, it’s a squared loss function (y-y’)^2 and for binary/multiclass classification, it’s zero/one loss function.

zero/one loss: l(y, y’) = { 0, y=y’ }
{ 1, otherwise }

Where y is the actual value and y’ is the predicted value.

The lesser the error while predicting, the more generalized is the model.

Why do we have different loss functions for different learning problems? And why do we have different learning problems in the first place?

Here are some of the learning problems:

Regression: predicting discrete future values based on past data. Example: The amount of rainfall on next Sunday.

Binary Classification: non-discrete binary values. Example: would it rain on Sunday or not? It will give 0 for No and 1 for yes.

Multiclass Classification: putting an example into one of a number of classes. Example: if a particular course belongs to computer science or earth sciences or educational sciences.

Ranking: putting the objects in a set of relevance. Example: arranging search results based on the user’s query.

The main reason to break learning problems into different genres is for measuring the error. A good model is the one that makes “good predictions”. Now, what do good predictions mean? Different types of learning problems differ in the way they define goodness. For example: predicting a rainfall that is off by 0.5 cm is much better than off by 300 cm. The same does not hold for multiclass classification. There, predicting computer science instead of earth sciences would be horrifying. Here, we can’t even afford slightest of the error. This is the reason why we break the problems into different categories and hence they have different loss functions. Thus, a good model is one that can generalize itself and can perform well on the unseen data.

Please, feel free to provide me any feedback and corrections on this piece. In the next article, I’m planning to talk about implementing a decision tree classifier and introducing inductive bias in the learning. You can also check out my previous article on Natural Language Processing over here

A Web Tracker to record HTTP/S requests and cookies.

Jaydeep Borkar — Fri, 14 Sep 2018 17:56:42 +0000

A few weeks ago, I was contributing for building a web tracker to record HTTP/S requests and cookies from the browser(restricted to Google Chrome). An extension that records user sessions on a click, a user can stop the recording on a click as per the wish, it would be then converted into JMeter script and can be used for load testing. All the extensions that are there in the market, they just record the user session of a single tab. Is it possible to integrate user sessions from multiple tabs and use them for testing? Does it make any sense?

Introduction to Natural Language Processing, Part 1.

Jaydeep Borkar — Sun, 09 Sep 2018 17:40:28 +0000

Hello folks, I’ve just started my NLP journey and will be happy to share my learning process with you. Here’s an article regarding Introduction to Natural Language Processing.

The essence of Natural Language Processing lies in making computers understand our natural language. That’s not an easy task though. Computers can understand the structured form of data like spreadsheets and the tables in the database, but human languages, texts, and voices form an unstructured category of data, and it gets difficult for the computer to understand it, and there arises the need for Natural Language Processing.

There’s a lot of natural language data out there in various forms and it would get very easy if computers can understand and process that data. We can train the models in accordance with our expected output in different ways. Humans have been writing for thousands of years, there are a lot of literature pieces available, and it would be great if we make computers understand that. But the task is never going to be easy. There are various challenges floating out there like understanding the correct meaning of the sentence, correct Named-Entity Recognition(NER), correct prediction of various parts of speech, coreference resolution(the most challenging thing in my opinion).

Computers can’t truly understand the human language. If we feed enough data and train a model properly, it can distinguish and try categorizing various parts of speech(noun, verb, adjective, supporter, etc…) based on previously fed data and experiences. If it encounters a new word it tried making the nearest guess which can be embarrassingly wrong few times.

It’s very difficult for a computer to extract the exact meaning from a sentence. For an example - The boy radiated fire like vibes. The boy had a very motivating personality or he actually radiated fire? As you see over here, parsing English with a computer is going to be complicated.

There are various stages involved in training a model. Solving a complex problem in Machine Learning means building a pipeline. In simple terms, it means breaking a complex problem into a number of small problems, making models for each of them and then integrating these models. A similar thing is done in NLP. We can break down the process of understanding English for a model into a number of small pieces.

My friend recently went for diving at San Pedro island, so I’ll love to take that example. Have a look at this paragraph - San Pedro is a town on the southern part of the island of Ambergris Caye in the Belize District of the nation of Belize, in Central America. According to 2015 mid-year estimates, the town has a population of about 16,444. It is the second-largest town in the Belize District and largest in the Belize Rural South constituency.

(source-Wikipedia)

It would be really great if a computer could understand that San Pedro is an island in Belize district in Central America with a population of 16,444 and it is the second largest town in Belize. But to make the computer understand this, we need to teach computer very basic concepts of written language.

So let’s start by creating an NLP pipeline. It has various steps which will give us the desired output(maybe not in a few rare cases) at the end.

STEP 1: Sentence Segmentation

Breaking the piece of text in various sentences.

San Pedro is a town on the southern part of the island of Ambergris Caye in the 2.Belize District of the nation of Belize, in Central America.
According to 2015 mid-year estimates, the town has a population of about 16,444.
It is the second-largest town in the Belize District and largest in the Belize Rural South constituency.

For coding a sentence segmentation model, we can consider splitting a sentence when it encounters any punctuation mark. But modern NLP pipelines have techniques to split even if the document isn’t formatted properly.

STEP 2: Word Tokenization

Breaking the sentence into individual words called as tokens. We can tokenize them whenever we encounter a space, we can train a model in that way. Even punctuations are considered as individual tokens as they have some meaning.
‘San Pedro’,’ is’, ’a’, ’town’ and so.

STEP 3: Predicting Parts of Speech for each token

Predicting whether the word is a noun, verb, adjective, adverb, pronoun, etc. This will help to understand what the sentence is talking about. This can be achieved by feeding the tokens( and the words around it) to a pre-trained part-of-speech classification model. This model was fed a lot of English words with various parts of speech tagged to them so that it classifies the similar words it encounters in future in various parts of speech. Again, the models don’t really understand the ‘sense’ of the words, it just classifies them on the basis of its previous experience. It’s pure statistics.

The process will look like this:
Input --->Part of speech classification model→ Output
Town common noun
Is verb
The determiner

And similarly, it will classify various tokens.

STEP 4: Lemmatization
Feeding the model with the root word.
For an example - There’s a Buffalo grazing in the field.
There are Buffaloes grazing in the field.
Here, both Buffalo and Buffaloes mean the same. But, the computer can confuse it as two different terms as it doesn’t know anything. So we have to teach the computer that both terms mean the same. We have to tell a computer that both sentences are talking about the same concept. So we need to find out the most basic form or root form or lemma of the word and feed it to the model accordingly.

In the similar fashion, we can use it for verbs too. ‘Play’ and ‘Playing’ should be considered as same.

STEP 5: Identifying stop words

There are various words in the English language that are used very frequently like ‘a’, ‘and’, ‘the’ etc. These words make a lot of noise while doing statistical analysis. We can take these words out. Some NLP pipelines will categorize these words as stop words, they will be filtered out while doing some statistical analysis. Definitely, they are needed to understand the dependency between various tokens to get the exact sense of the sentence. The list of stop words varies and depends on what kind of output are you expecting.

STEP 6.1: Dependency Parsing

This means finding out the relationship between the words in the sentence and how they are related to each other. We create a parse tree in dependency parsing, with root as the main verb in the sentence. If we talk about the first sentence in our example, then ‘is’ is the main verb and it will be the root of the parse tree. We can construct a parse tree of every sentence with one root word(main verb) associated with it. We can also identify the kind of relationship that exists between the two words. In our example, ‘San Pedro’ is the subject and ‘island’ is the attribute. Thus, the relationship between ‘San Pedro’ and ‘is’, and ‘island’ and ‘is’ can be established.

Just like we trained a Machine Learning model to identify various parts of speech, we can train a model to identify the dependency between words by feeding many words. It’s a complex task though. In 2016, Google released a new dependency parser Parsey McParseface which used a deep learning approach.

STEP 6.2: Finding Noun Phrases

We can group the words that represent the same idea. For example - It is the second-largest town in the Belize District and largest in the Belize Rural South constituency. Here, tokens ‘second’, ‘largest’ and ‘town’ can be grouped together as they together represent the same thing ‘Belize’. We can use the output of dependency parsing to combine such words. Whether to do this step or not completely depends on the end goal, but it’s always quick to do this if we don’t want much information about which words are adjective, rather focus on other important details.

STEP 7: Named Entity Recognition(NER)

San Pedro is a town on the southern part of the island of Ambergris Caye in the 2. Belize District of the nation of Belize, in Central America.

Here, the NER maps the words with the real world places. The places that actually exist in the physical world. We can automatically extract the real world places present in the document using NLP.

If the above sentence is the input, NER will map it like this way:
San Pedro - Geographic Entity
Ambergris Caye - Geographic Entity
Belize - Geographic Entity
Central America - Geographic Entity

NER systems look for how a word is placed in a sentence and make use of other statistical models to identify what kind of word actually it is. For example - ‘Washington’ can be a geographical location as well as the last name of any person. A good NER system can identify this.

Kinds of objects that a typical NER system can tag:
People’s names.
Company names.
Geographical locations
Product names.
Date and time.
Amount of money.
Events.

STEP 8: Coreference Resolution:

San Pedro is a town on the southern part of the island of Ambergris Caye in the Belize District of the nation of Belize, in Central America.
According to 2015 mid-year estimates, the town has a population of about 16,444.
It is the second-largest town in the Belize District and largest in the Belize Rural South constituency.

Here, we know that ‘it’ in the sentence 6 stands for San Pedro, but for a computer, it isn’t possible to understand that both the tokens are same because it treats both the sentences as two different things while it’s processing them. Pronouns are used with a high frequency in English literature and it becomes difficult for a computer to understand that both things are same. Hence, this step is used. This step is indeed the most difficult step

In the upcoming articles, I’ll try sharing about the history of NLP, how it evolved, various past models and why they failed, NLP Libraries and coding NLP pipeline in Python. I’d love discussing various papers as well.

Please, feel free to correct me on any topic if I went wrong somewhere and do let me know about improvements.

Note - I will be soon publishing this article on Geeksforgeeks as well, so that we all can get into getting the knowledge together.

How to embed graph in Django for the users

Jaydeep Borkar — Wed, 05 Sep 2018 14:48:03 +0000

I want to show a graph(using matplotlib) to the user. In which Django directory should I place my code?

mysite/

graph/
my_matplotlib/
init.py
my_matplotlib.py
graphcode.py (basically, the code for the graph)

app/
views.py
from my_matplotlib.my_matplotlib import my_func

my_matplotlib.py

def my_func():
foo = 'bar'
return foo

I tried this but it's not working.