DEV Community: Thirasha Praween

Basic Understanding of Cost Function + Formula

Thirasha Praween — Sat, 11 Sep 2021 10:02:31 +0000

The Linear Regression algorithm can get the best fit line for our data set. We mostly use it to predict future values. But, when we use linear regression, We can see little errors on predicted values rather than on the actual data points. Sometimes, the actual value and predicted value can be change. In this post, see what is the Cost Function is.
There are many Cost Functions in machine learning. Each has its occasion depending on whether it's a regression or classification problem.

Regression Cost Function
Binary Classification Cost Functions
Multi-class Classification Cost Functions

What is an Error?

Always I try to give a simple answer for better understanding. Look at the linear regression graph below. In that graph, we can see the difference between the actual value and the predicted value. Basically, that difference is an "error". If you don't understand what is linear regression is, I would recommend reading my previous article about linear regression.

Math Behind Simple Linear Regression + Scikit Learn

Thirasha Praween ・ Aug 25 ・ 4 min read

#ai #machinelearning #python #jupyter

Cost Function

So Cost Function helps to understand the difference between the actual value and predicted value. The definition of the Cost Function is "It's a function that determines how well a Machine Learning model performs for a given set of data."

What is the formula of Cost Function?

The Cost Function has many different formulations. Let's see the Cost Function for linear regression with a single variable.

m: Is the number of our training examples.
i: The number of Examples and the Output.
Σ: The Summatory.
h: The Hypothesis of our Linear Regression Model

In addition, we can find the Cost Function with this simple formula below.

So, how can we make the Cost Function as little as possible? the gradient descent is the best method rather than linear regression for minimizing the Cost Function. We'll talk about that later.

Understanding Logistic Regression — Binary Classification

Thirasha Praween — Sat, 04 Sep 2021 13:45:01 +0000

Why do we need logistic regression rather than linear regression? Actually, we can use linear regression for those regression problems but let's talk about why we need this. I recommended reading my previous article about Linear Regression. In this article, we'll talk about logistic regression and train a simple logistic regression model using Scikit Learn.

Math Behind Simple Linear Regression + Scikit Learn

Thirasha Praween ・ Aug 25 '21

#ai #machinelearning #python #jupyter

Typically, Logistic Regression use for classification problems. It has two categories,

Binary Classification
Multi Class Classification

Why Logistic Regression?

Logistic Regression is usually used for binary classification. Let's get a simple example for binary classification. We have some data set students who are whether pass or fail the exam with weekly study hours. Also, We can represent pass as 1 and fail as 0.

Study Hours	Result
2	Fail
3	Fail
5	Fail
7	Fail
10	Fail
11	Fail
12	Fail
13	Pass
14	Pass
16	Pass
17	Fail
18	Pass
20	Pass
22	Pass
23	Pass

Let's see what happens when we plot these data and get the best fit line using linear regression. First, you have to save this data into a .csv file like this. In my case, book.csv is the file name.

Usage

Open jupyter notebook and start with installing some libraries that we need to perform this task.

!pip install numpy
!pip install pandas
!pip install matplotlib

Import those libraries

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

Read book.csv file

data = pd.read_csv("book.csv")

Assign hours and results values as numpy array

hours = np.array(data['hours'].values)
results = np.array(data['result'].values)

Plot data using matplotlib library.

plt.scatter(hours, results, color='green')
plt.xlabel("Hours")
plt.show()

You can see the graph like this.

Draw best fit line

# m - slope
# b - intercept
m,b = np.polyfit(hours,results,1)
plt.xlabel("Hours")
plt.plot(hours, results, 'o', color='green')
plt.plot(hours,m*hours+b)

So, if we draw a line y=0.5, We can see mostly 13 or less than study hours students are failed, and others are passed the exam because the y value is 0.5 or higher.

Typically, We can conclude that the linear regression is correct for this. But what happen if I add some higher values to that data set?

The graph and best fit line will change like this

So now, If divide from y=0.5, we can see something wrong in the linear regression. It's not a fair line as the previous one.

Come back to the main topic, "Why Logistic Regression?". Now you understand that there is a issue with the linear regression for classification problems. If we add more higher data records, it will never get a fair line, therefore, we cannot satisfy with the output. That's why we use logistic regression for classification problems like this.

In a nutshell, when we come to a classification problem, we have to use a sigmoid function instead of a straight line. It looks like an S shape graph. Not a straight line. The formula of the sigmoid function is,

Therefore, When we get the previous original data set (without newly added two data points), we had 15 data records. So now, the graph will look like this using the sigmoid function.

If we divide from y=0.5, more than 0.5 (y>0.5) are passed students, and lower than 0.5 (y<0.5) are failed students. Also, we can dismiss some data points that I marked in the graph below because those will occur rarely.

Implement Logistic Regression - Scikit Learn

Using the Python Scikit Learn library, We can implement and train a logistic regression model. In this case, We use 15 records data set (without newly added two data records) and implement binary classification.

Install Scikit Learn library

!pip install scikit-learn

Import necessary libraries

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# for divide data set to train data and test data
from sklearn.model_selection import train_test_split
# logistic regression model
from sklearn.linear_model import LogisticRegression

Read book.csv file using pandas

data = pd.read_csv("book.csv")

Take hours as x values and results as y values

# x_data as 2d array
x_data = data[['hours']]
y_data = data['result']

Then, divide the data set into train and test sections using the train_test_split method. In my case added the random_state=2 parameter to prevent the data changes by random. In your case, you can use any number or dismiss it. Also, you can add the test_size parameter to change the percentage of the test data set if you want. (default - 0.25)

x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, random_state=2)

If you execute len(x_train) and len(x_test), you can see the length of those data sets. in my case, x_train length is 11, x_test length is 4.

Create a logistic regression model object and train the model.

model = LogisticRegression()
model.fit(x_train, y_train)

Alright, now we can predict the result using the model. To do that, we can use x_test data.

model.predict(x_test)
# predicted result - array([1, 0, 0, 0], dtype=int64)

Then we have to know whether it is correct or not. We can manually check by executing y_test. For me, the result is,

11    1
4     0
5     0
0     0
Name: result, dtype: int64

That is exactly the same as the predicted result👏. Also, you can test with your own data using the model.

Using four study hours values,

model.predict([[6], [15], [19], [25]])
# predicted result - array([0, 1, 1, 1], dtype=int64)

Study Hours	Result
6	Fail
15	Pass
19	Pass
25	Pass

Get the score of prediction accuracy,

model.score(x_test, y_test)
# 1.0

For me, It's 1.0. That means 100% accuracy. But in your case, It may vary depending on the length of the data set and the trained data set.

Optional

If you want to see the sigmoid curve according to the data set, you need to install another library to make it easier.

!pip install seaborn

Import and regplot it with book.csv data.

import seaborn as sns
sns.regplot(x='hours', y='result', data=data, logistic=True)

Math Behind Simple Linear Regression + Scikit Learn

Thirasha Praween — Wed, 25 Aug 2021 19:03:08 +0000

Linear Regression is basically a used type of predictive analysis and one of the most simple algorithms in machine learning. It attempts to measure the relationship between variables by fitting a linear equation to observed data. For example, when the mobile phone's age increases, the price will go down. So, one variable is an explanatory variable (Age). Or otherwise, we can say it's an independent variable. And the other one is considered to be the dependent variable (Price).

From that example, we can say the future price of the mobile phone using that observed data. Here is a table of the example data.

Mobile Phone Age (Years)	Price ($)
1	250
2	230
5	190
6	160
8	120
9	90
10	70
11	40

In this case, we see that a negative relationship between mobile phone age and price. Why do I say that, when the mobile phone's age increases, the price will decrease.

Another example is when experience increases, so do the salary. It's a positive relationship.

We're trying to predict the mobile phone's future prices given the age like this.

The question is what is the price after 7 years?. Let's put a point there to see how much it is.

It's a little bit lower than one hundred and fifty usd. So, Now see the mathematical side behind simple linear regression. The formula is y = mx + b. I know you're a little bit familiar with this formula. because mostly we all learned this in school.

y - What we are going to predict. In this case, mobile phone price (dependent variable)
m - Slope or constant
x - Input as 7 years (independent variable)
b - Intercept

And m and b are given by the following formula.

Find the linear regression equation for that mobile phone price data set.

x (Years)	y (Price)	x²	xy
1	250	1	250
2	230	4	460
5	190	25	950
6	160	36	960
8	120	64	960
9	90	81	810
10	70	100	700
11	40	121	440
(∑x) = 52	(∑y) = 1,150	(∑x²) = 432	(∑xy) = 5,530

Okay, now we can assign those values to that formulas and get the value of m and b.

Find m - Slope

Find b - Intercept

Predict the mobile phone price after 7 years. using y = mx + b. The y is the price of the mobile phone after 7 years (that we're going to predict). x is 7 years.

The mobile phone price after 7 years is 133.40 usd. Now do the same thing with scikit learn linear regression model using Python.

Linear Regression Model (Scikit Learn)

First, We have to save that data set into a csv file. To do that, create a new csv file as mobiledata.csv and add those data like this.

Let's code it! I'm using Jupyter Notebook. You can use any Python IDE as you prefer. Next, Install the libraries that we need. (If you are using Jupyter Notebook, add an exclamation mark before the command to act as if it is executed in the terminal)

!pip install scikit-learn
!pip install numpy
!pip install pandas
!pip install matplotlib

Import those libraries

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression

Read the mobiledata.csv file using pandas

data_set = pd.read_csv('mobiledata.csv')

Create a chart and put the points there

plt.scatter(data.age, data.price, color='red')
plt.xlabel('Mobile phone Age')
plt.ylabel('Price')

You can see the chart like this.

Get the age values as x and price values as y. We need to convert those values to a numpy array.

x = np.array(data.age.values)
y = np.array(data.price.values)

Create a linear regression class object and train the model using the fit function. Also, the model.fit function allows a two-dimensional array to x position.

model = LinearRegression()
model.fit(x.reshape((-1,1)), y)
# x.reshape((-1,1) is convert numpy array to two dimensional array

We can find the best fit line for this data set if we want. And get the values of m (Slope) and b (Intercept).

plt.scatter(data.age, data.price, color='red')
plt.xlabel('Mobile phone Age')
plt.ylabel('Price')
m,b = np.polyfit(x,y,1)
plt.plot(x,m*x+b)

Finally, predict the mobile phone price after 7 years using the model. The model object is defined as model. Predict the price to see whether it's equal to the previously calculated value or not. To do that, We need to convert x value (7) to a numpy array and two-dimensional array.

year_seven = np.array([7]).reshape((-1,1))
# Predict the price
model.predict(year_seven)

You'll see the price after predict using the model is exactly the same as the previously calculated value that We using the formula.

# array([133.40425532])

You can check the values of m and b by executing the variable in the notebook.

m
# -20.691489361702125

b
# 278.2446808510638

Happy Coding🎉

Deno WebSocket Realtime Chat App + TypeScript

Thirasha Praween — Sun, 15 Aug 2021 17:58:03 +0000

One of the things that interested me when I was learning Deno is creating a real-time chat application. but when I was learning NodeJs with WebSocket, I've created and deployed a chat application called fostlet. You can go and try it with different chat rooms.

In this post, I'll show you how to build a simple chat application with Deno using TypeScript. Deno supports both JavaScript and TypeScript as first-class languages at runtime. This means it requires fully qualified module names, including the extension (or a server providing the correct media type). Typescript modules can be directly imported. So I think TypeScript is better for Deno.

Installation

First you should install Deno on your computer if you haven't. Basically, you can install the setup by running a simple command.

Usage

We'll develop this chat app with WebSocket. WebSocket is a library that allows us to do real-time, bidirectional, and event-based communication between the browser and the server.

Step 1

Create a new file called index.html in a new folder and write the code below to create a simple user interface.

<div class="container">
  <form class="init_form">
    <input type="text" name="name" placeholder="Enter your name" required />
    <button>Start Chat</button>
  </form>

  <div class="msg_room">
    <ul class="msg_list"></ul>
    <form class="msg_form">
      <input type="text" name="msg" placeholder="Type a message" required />
      <button>Send</button>
    </form>
  </div>
</div>

Also, add some styles using a style tag inside the index.html file. More customizations are up to you.

<style>

    body{
        font-family: 'Lucida Sans', 'Lucida Sans Regular', 'Lucida Grande', 'Lucida Sans Unicode', Geneva, Verdana, sans-serif;
    }
    .container{
        width: 100vw;
        height: 100vh;
        display: flex;
        justify-content: center;
        align-items: center;
        flex-direction: column;
    }
    input[type=text]{
        padding: 5px;
        border-radius: 5px;
        border: #888 2px solid;
        width: 250px;
    }
    button{
        padding: 5px;
        background-color: #eee;
        border-radius: 5px;
        outline: none;
    }
    .msg_room{
        display: none;
    }
    .pname{
        font-weight: bold;
        margin-left: 5px;
    }
    .pmsg{
        background-color: #eee;
        border-radius: 10px;
        padding: 10px;
        margin-bottom: 10px;
    }
    ul{
        list-style: none;
    }

</style>

Okay, let's do JavaScript, inside index.html create a new <script> tag to write JS for handle message submit, username submit, and WebSocket implementation on the client-side.

Select Dom elements and WebSocket

const initForm = document.querySelector('.init_form');
const msgRoom = document.querySelector('.msg_room');
const msgList = document.querySelector('.msg_list');
const msgForm = document.querySelector('.msg_form');
const ws = new WebSocket('ws://localhost:3000/ws');

Handle name form submission request

initForm.addEventListener('submit', (e) => {
    e.preventDefault();
    name = initForm.name.value;
    msgRoom.style.display = "block"
    initForm.style.display = "none"
});

Handle message form submission request and send to the server-side in JSON format.

msgForm.addEventListener('submit', e => {
    e.preventDefault();
    const msg = msgForm.msg.value;
    ws.send(JSON.stringify({
        name,
        msg
    }));
    msgForm.msg.value = '';
});

Output incoming message in the client side, with HTML elements.

const msgOutput = ({ data }) => {
    const { name, msg } = JSON.parse(data);
    const li = `
        <li>
            <div class="pname">${name}</div>
            <div class="pmsg">${msg}</div>
        </li>
    `;
    msgList.innerHTML += li;
}

Finally, add event listener for WebSocket.

ws.addEventListener('message', msgOutput);

Step 2

Alright! Now client side is done. The next move is to create a server-side connection. Create a new file connection.ts at the same as the index.html directory.

Import WebSocket and random user id generating library

import { WebSocket, isWebSocketCloseEvent } from "https://deno.land/std/ws/mod.ts";
import { v4 } from "https://deno.land/std/uuid/mod.ts";

Implement WebScoket

let sockets = new Map<string, WebSocket>();

Create TypeScript interface for event broadcaster function and define the function as eventBrodcaster.

interface BrodcastInterface {
    name: string,
    msg: string
};

const eventBrodcaster = (obj: BrodcastInterface) => {
    sockets.forEach((ws: WebSocket) => {
        ws.send(JSON.stringify(obj));
    });
}

Now create the connection to handle requests.

const connection = async (ws: WebSocket) => {

    // New websocket and generate new user id
    const uid = v4.generate();
    sockets.set(uid, ws);

    for await (const ev of ws){

        // remove socket if user close the tab or browser
        if(isWebSocketCloseEvent(ev)){
            sockets.delete(uid);
        }

        // broadcast the message that user sent
        if(typeof ev === 'string'){
            let evObj = JSON.parse(ev);
            eventBrodcaster(evObj);
        }
    }
}

Export the connection at the very bottom of the file.

export { connection };

Step 3

Okay, This is the final step, create new file server.ts at the same as index.html and connection.ts directory.

Import serve, WebSocket libraries and the connection.ts file.

import { serve } from "https://deno.land/std/http/server.ts";
import { acceptWebSocket, acceptable } from "https://deno.land/std/ws/mod.ts";
import { connection } from './connection.ts';

Setup server to listen port 3000 and add a console.log if you want.

const server = serve({ port: 3000 });
console.log("Chat app listening on port 3000");

Listen to the browser routes of the root directory and WebSocket directory.

for await (const req of server){
    // serve index.html file - route /
    if(req.url === '/'){
        req.respond({
            status: 200,
            body: await Deno.open('./index.html')
        });
    }

    // serve websocket route and accept socket - route /ws
    if(req.url === '/ws'){
        if(acceptable(req)){
            acceptWebSocket({
                conn: req.conn,
                bufReader: req.r,
                bufWriter: req.w,
                headers:req.headers
            })
            .then(connection)
        }
    }
}

Now all done!. If you have already installed Deno, run this command in the terminal at the project directory.

--allow-net for allow network access. --allow-read for read files.

deno run --allow-net --allow-read server.ts

Now you can see your simple chat app live on the port number 3000.
Follow me on Twitter

Happy Coding!🎉

Create a Synthesizes Natural Sounding Speech From Text Tool

Thirasha Praween — Wed, 11 Aug 2021 12:36:41 +0000

You've probably used whatever text to speech tool at least once. So in this post, We'll create your own text-to-speech tool with an audio exporting feature using Python.

Basically, We'll use IBM Watson Text to Speech Machine learning model. IBM Watson helping enterprises put AI to work and helps organizations predict future outcomes, automate complex processes, and optimize employees’ time.

Register with IBM Cloud

To Getting started with the Text to Speech model, You have to register with IBM Cloud. Go to IBM Cloud and create a new free account.

After that, you have to create lite plan instances of the model. To create that, go to the Text to Speech model page and then create a free instance by clicking Create button.

Afterward, you'll see the getting started page. Go to the Manage page to get model credentials which are API key and URL. Now registration process is completed.

Usage

First, have to install the ibm_watson on your computer.

pip install ibm_watson

If you are using Jupyter Notebook, add an exclamation mark before the command to act as if it is executed in the terminal.

!pip install ibm_watson

Authenticate

Import TextToSpeech model, Watson authenticator and authenticate with API key and the URL.

from ibm_watson import TextToSpeechV1
from ibm_cloud_sdk_core.authenticators import IAMAuthenticator

Specify the API Key and URL

url = '<your-api-url>'
apiKey = '<your-api-key>'

authenticator = IAMAuthenticator(apiKey)
tts = TextToSpeechV1(authenticator=authenticator)
tts.set_service_url(url)

Setup Text to Speech

In this step, we'll look at how to speak a text from string and text files.

From String

with open('./speech.mp3', 'wb') as audio_file:
    res = tts.synthesize('Hello World! I\'m Thirasha', accept='audio/mp3', voice='en-US_AllisonV3Voice').get_result()
    audio_file.write(res.content)

In a while, it will generate that string to an audio file and export it as speech.mp3 at the root directory.

From Text File

with open('SpeechText.txt', 'r') as f:
    text = f.readlines()

Remove line breaks

text = [line.replace('\n', '') for line in text]
text = ''.join(str(line) for line in text)

Export audio file

with open('./speech.mp3', 'wb') as audio_file:
    res = tts.synthesize(text, accept='audio/mp3', voice='en-US_AllisonV3Voice').get_result()
    audio_file.write(res.content)

Change Language and Voice (Optional)

If you want to change the voice or language, refer to this IBM Languages and Voices documentation.

For example, If I have chosen the German female voice de-DE_BirgitV3Voice, that code should be change like this.

with open('./germanspeech.mp3', 'wb') as audio_file:
    res = tts.synthesize('Hallo Welt! Ich bin Thirasha', accept='audio/mp3', voice='de-DE_BirgitV3Voice').get_result()
    audio_file.write(res.content)

Eventually, You have created your own Speech-To-Text generating tool!🎉

Django Easy Deployment On Heroku

Thirasha Praween — Thu, 05 Aug 2021 10:42:41 +0000

In this post, We'll be settings up a Django project to deploy on Heroku. Heroku is an almost free platform for users to deploy their python, node js, and other framework-based applications.

Setup Django Project for Deployment

1. First, I would recommend making a copy of your project or use a separate git branch.

2. Make sure the python virtual environment is activated.

3. You have to create a text file called requirements.txt at the root of the project to add all dependencies with their versions.

So to do that, you can manually type the dependency list and the versions you used for your Django project.
or
Try the freeze command on your terminal at the project root directory

pip freeze > requirements.txt

In my case, the example of the requirements.txt file.

Sometimes, if you have installed huge python libraries on your computer, this might be a change. That means the requirements.txt file will have every library that you installed on the computer. Also, mostly the Django project doesn't need those other libraries. So there's a way to fix this problem that I would recommend. You have to install a simple library called pipreqs.

pip install pipreqs

Okay, then open your terminal and run this command.

Usage

pipreqs <your-project-location>

After the process, you can see it will output.

Successfully saved requirements file in <your-project-location>/requirements.txt

Okay, In my case, now the requirements.txt file contains I used dependencies in the project only. You will have your own dependency list.

4. Add this code line in the settings.py file.

STATIC_ROOT = os.path.join(BASE_DIR, 'static')

5. Next, if you don't have a Heroku account, create a new Heroku account.

6. Download and install Heroku CLI.

7. In this step, you have to configure Django-Heroku.

Make a file called Procfile at the root of the project. (do not add any file extension like .txt .py). The file name must be only Procfile).

This file is used to explicitly declare your application’s process types and entry points. It is located at the root of your project.

Write code line inside Procfile.

web: gunicorn <your-project-name>.wsgi

For more details, refer django-heroku documentation.

Okay, then you have to install two more libraries. This Procfile requires Gunicorn, the production web server that Heroku recommend for Django applications.

pip install gunicorn

pip install django-heroku

In the settings.py import django_heroku top of the file.

import django_heroku

Also, add this code line bottom of the settings.py file to activate django-heroku.

django_heroku.settings(locals())

Then, you have to add those gunicorn and django_heroku libraries in the requirements.txt file. In my case, the requirements.txt file.
(You can get those two dependencies versions by running the pip list command.)

8. Finally, run those commands one by one in the terminal on the project root directory.

git init
git add .
git commit -m "first commit"

heroku login
heroku create <your-app-name>
git push heroku master
heroku open

You can see your project will open after the successful deployment. But if you used SQLite database on the project, it will show the missing database error . Run database migration to fix the issue.

heroku run python manage.py migrate

Now your project is live on Heroku🎉

Optional

If this not working or getting some other errors, Close your terminal and re-open it. Then change these code lines in the settings.py file.

DEBUG = False

ALLOWED_HOSTS = ['<your-app-name>.herokuapp.com', 'localhost', '127.0.0.1']

If you made those edits, then run these commands in the terminal

git add .
git commit -m "settingspy edited"
git push heroku master

Hope it will work!👏🎉

Build Your Android App with HTML, CSS, JS

Thirasha Praween — Sun, 25 Jul 2021 09:31:33 +0000

In this post, we'll be settings up RearGen to build your first android app with HTML, CSS, and JS.

As you know to become an android developer, first, you have to learn about android studio, java, XML, and Gradle. after that android developers move to any other framework to build apps with more ease and more platform support.

RearGen is a pre-developed framework tool that developers or non-developers can use. It's working with native based backend and the tool made with python. If someone wants to build an android web app to their hosted website. RearGen is the best selection for that. RearGen makes a signed android app to your hosted website with additional features like a no-internet connection window, pull and refresh button, splash screen, etc.

Although, If someone can't host their mobile responsive website, they can develop the app with HTML, CSS, and JS. This feature is called In-app development. You can develop your mobile app with basic HTML, CSS, and JS knowledge. otherwise, you can use third-party CSS and JS library, templates, and any other browser-supported things. Below I listed the main features in RearGen.

Running with native code base backend
Fast and easy
Build less than 5MB app
More customisation
Connection lost window
Pull and refresh facility
No SSL bypass
High quality rendering
Develop with HTML / CSS / JavaScript
Generating support
Live testing
Live installing
Recollecting feature
Full debugging details
External CSS and JavaScript libraries supported
Third party library support

Installation

First, you need to download the latest RearGen release or LTS release from GitHub or clone the repo. After that, install supported JDK 8 or JDK 16 or whatever supported version on your computer. then, follow the Start Development instructions on my GitHub.

These are sample splash and home screens. you can code whatever you want. Also, you can find out this sample RearGen mobile app on Play Store.

Splash Screen	Home Screen

Using custom template or library

To use a custom template, place the template files in the src folder in the RearGen root directory. those instructions you can find out on my RearGen GitHub repository.

RearGen does not come with mobile-responsive components. So fornyKit is also known as RearGen Material Kit handles HTML elements as android responsive components. Try fornyKit to your RearGen project.

Happy coding🎉!

RolarBot: AI Paragraph Questions and Answers

Thirasha Praween — Sat, 24 Jul 2021 17:53:38 +0000

RolarBot is a AI powered tool of paragraph decoding. Basically used natural language processing. Natural language processing is a subfield of linguistics, computer science, and artificial intelligence concerned with the interactions between computers and human language, in particular how to program computers to process and analyse large amounts of natural language data.

First, you have to input a paragraph and after that, ask some questions from that paragraph. Finally, Rolarbot will give you the best answers and the scores.

This tool mostly important for high school and university students. I developed this tool using TensorFlow NLP model. also BERT. BERT aka bidirectional Encoder Representations from Transformers is a transformer-based machine learning technique for natural language processing pre-training developed by Google. BERT was created and published in 2018 by Jacob Devlin and his colleagues from Google.

Okay, let's try your first question with RolarBot.

Update

Now you can install the RolarBot android app from the play store. That mobile app is 20X faster than RolarBot web.

Install RolarBot App

Give your feedback after using the mobile app.