<h4>Explaining what is the error of linear regression and formula of the cost function</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_DVBQAqeppv4YBtUr8dfHg.png"></figure>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.
<ul>
<li>Regression Cost Function</li>
<li>Binary Classification Cost Functions</li>
<li>Multi-class Classification Cost Functions</li>
</ul>
<h3>What is an Error?</h3>
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 <a href="https://thirashapraween.medium.com/math-behind-simple-linear-regression-scikit-learn-175225cb851b">linear regression</a>.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/368/1*h6ZP_9l47zirSLa3gwUIsg.png"><figcaption>Difference between actual and predicted values</figcaption></figure><h3>Cost Function</h3>
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.”
<h3>What is the formula of Cost Function?</h3>
The Cost Function has many different formulations. Let’s see the Cost Function for linear regression with a single variable.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/590/1*SoHYZKKlGric6XSYhObG3A.png"></figure><ul>
<li>
m: Is the number of our training examples.</li>
<li>
i: The number of Examples and the Output.</li>
<li>
h: The Hypothesis of our Linear Regression Model</li>
</ul>
In addition, we can find the Cost Function with this simple formula below.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/727/1*tMKSfzMVxPtuqXPD1uYqXw.png"></figure>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.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=7fbad7b6fe4" width="1" height="1" alt="">

Basic Understanding of Cost Function

<h3>Understanding Logistic Regression — Binary Classification</h3>
<h4>Step by Step Implement Scikit Learn Logistic Regression Model</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jWwANEbVj8UPFxMdIzrF9w.png"></figure>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 <a href="https://thirashapraween.medium.com/math-behind-simple-linear-regression-scikit-learn-175225cb851b">Linear Regression</a>. In this article, we’ll talk about logistic regression and train a simple logistic regression model using Scikit Learn.
Typically, Logistic Regression use for classification problems. It has two categories,
<ul>
<li>Binary Classification</li>
<li>Multi Class Classification</li>
</ul>
<h3>Why Logistic Regression?</h3>
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.
<a href="https://medium.com/media/10b91013ee2ede8693bbf26405eaab2d/href">https://medium.com/media/10b91013ee2ede8693bbf26405eaab2d/href</a>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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/205/1*STiZyclA8Yvb9FvOiAJe0A.png"><figcaption>book.csv file</figcaption></figure><h3>Usage</h3>
Open jupyter notebook and start with installing some libraries that we need to perform this task.
<pre>!pip install numpy !pip install pandas !pip install matplotlib</pre>
Import those libraries
<pre>import numpy as np import pandas as pd import matplotlib.pyplot as plt</pre>
Read book.csv file
<pre>data = pd.read_csv("book.csv")</pre>
Assign hours and results values as numpy array
<pre>hours = np.array(data['hours'].values) results = np.array(data['result'].values)</pre>
Plot data using matplotlib library.
<pre>plt.scatter(hours, results, color='green') plt.xlabel("Hours") plt.show()</pre>
You can see the graph like this.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/372/1*ZCXkYwjT3xidtNqpiUpp_w.png"></figure>Draw best fit line
<pre># 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)</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*9OxOh6oRVv0M8MJpfw7WCQ.png"><figcaption>Linear Regression</figcaption></figure>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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/380/1*cVyAY_1dStUY0eRCf36aig.png"></figure>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?
<figure><img alt="" src="https://cdn-images-1.medium.com/max/217/1*I1qn7O601z1snrXVPOscZw.png"><figcaption>Newly data added book.csv file</figcaption></figure>The graph and best fit line will change like this
<figure><img alt="" src="https://cdn-images-1.medium.com/max/377/1*6zGQ0-_eZQvICfbRQwHZgg.png"><figcaption>Linear Regression</figcaption></figure>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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/377/1*i1Ah67V5tpz9t7nEpxxRyw.png"></figure>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,
<figure><img alt="" src="https://cdn-images-1.medium.com/max/378/1*80FaVsoQ4DBCE7kXuStY3Q.png"><figcaption>Sigmoid function</figcaption></figure>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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/373/1*CtEZflbQRfrC-8h2kayzGw.png"><figcaption>Assumed sigmoid curve</figcaption></figure>If we divide from y=0.5, more than 0.5 (y&gt;0.5) are passed students, and lower than 0.5 (y&lt;0.5) are failed students. Also, we can dismiss some data points that I marked in the graph below because those will occur rarely.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/373/1*Ji_6-asfTy_F2_RyZe6fKg.png"></figure><h3>Implement Logistic Regression — Scikit Learn</h3>
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
<pre>!pip install scikit-learn</pre>
Import necessary libraries
<pre>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</pre>
Read book.csv file using pandas
<pre>data = pd.read_csv("book.csv")</pre>
Take hours as x values and results as y values
<pre># x_data as 2d array x_data = data[['hours']] y_data = data['result']</pre>
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)
<pre>x_train, x_test, y_train, y_test = train_test_split(x_data, y_data, random_state=2)</pre>
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.
<pre>model = LogisticRegression() model.fit(x_train, y_train)</pre>
Alright, now we can predict the result using the model. To do that, we can use x_test data.
<pre>model.predict(x_test) # predicted result - array([1, 0, 0, 0], dtype=int64)</pre>
Then we have to know whether it is correct or not. We can manually check by executing y_test. For me, the result is,
<pre>11 1 4 0 5 0 0 0 Name: result, dtype: int64</pre>
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,
<pre>model.predict([[6], [15], [19], [25]]) # predicted result - array([0, 1, 1, 1], dtype=int64)</pre>
Predicted result summary view,
<a href="https://medium.com/media/de28793ab1b904069ad378940ad4a85c/href">https://medium.com/media/de28793ab1b904069ad378940ad4a85c/href</a>Get the score of prediction accuracy,
<pre>model.score(x_test, y_test) # 1.0</pre>
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.
<h3>Optional</h3>
If you want to see the sigmoid curve according to the data set, you need to install another library to make it easier.
<pre>!pip install seaborn</pre>
Import and regplot it with book.csv data.
<pre>import seaborn as sns sns.regplot(x='hours', y='result', data=data, logistic=True)</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/386/1*oJN22y7L_5bvXurKwageeQ.png"><figcaption>Sigmoid curve</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=9460d1d6a373" width="1" height="1" alt="">

Understanding Logistic Regression — Binary Classification

<h4>Step by step prove simple linear regression formula with Scikit Learn</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TXAt04G3D2jnF1maPmYMlw.png"><figcaption>Cover by Author</figcaption></figure>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.
<a href="https://medium.com/media/af21ded1e74df7c2dfcc4f4c2713fa62/href">https://medium.com/media/af21ded1e74df7c2dfcc4f4c2713fa62/href</a>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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0Bgpx9JQb6ZBqT7Xl2vx1w.png"><figcaption>Photo by author</figcaption></figure>The question is what is the price after 7 years?. Let’s put a point there to see how much it is.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N2Ym5tWSaUrho9HovwJSCA.png"><figcaption>Photo by author</figcaption></figure>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.
<ul>
<li>y - What we are going to predict. In this case, mobile phone price (dependent variable)</li>
<li>m - Slope or constant</li>
<li>x - Input as 7 years (independent variable)</li>
<li>b - Intercept</li>
</ul>
And m and b are given by the following formula.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/526/1*vGuTGxkMCxhdf8eqXPabnw.png"><figcaption>Formula image by author</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/476/1*_HMThqgIbQCf0wJlWX-hUw.png"><figcaption>Formula image by author</figcaption></figure>Find the linear regression equation for that mobile phone price data set.
<a href="https://medium.com/media/132d1fef3bb16cc105de1cf8921b6872/href">https://medium.com/media/132d1fef3bb16cc105de1cf8921b6872/href</a>Okay, now we can assign those values to that formulas and get the value of m and b.
Find m - Slope
<figure><img alt="" src="https://cdn-images-1.medium.com/max/526/1*jCJ1I9IU4B-aZz6EuDCd3A.png"><figcaption>Photo by author</figcaption></figure>Find b - Intercept
<figure><img alt="" src="https://cdn-images-1.medium.com/max/465/1*MOXXvpdnZJlgDvd40Z3d4A.png"><figcaption>Photo by author</figcaption></figure>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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/574/1*lhdRCrgRxkThaGnAgLXGdg.png"><figcaption>Photo by author</figcaption></figure>The mobile phone price after 7 years is 133.40 usd. Now do the same thing with scikit learn linear regression model using Python.
<h3>Linear Regression Model (Scikit Learn)</h3>
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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/315/1*ZqgrL-UGt38AJaakduBFrQ.png"><figcaption>Photo by author</figcaption></figure>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)
<pre>!pip install scikit-learn !pip install numpy !pip install pandas !pip install matplotlib</pre>
Import those libraries
<pre>import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.linear_model import LinearRegression</pre>
Read the mobiledata.csv file using pandas
<pre>data_set = pd.read_csv('mobiledata.csv')</pre>
Create a chart and put the points there
<pre>plt.scatter(data.age, data.price, color='red') plt.xlabel('Mobile phone Age') plt.ylabel('Price')</pre>
You can see the chart like this.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/389/1*2vlhdwY-RycBWJmx_-t-pg.png"><figcaption>Chart image by author</figcaption></figure>Get the age values as x and price values as y. We need to convert those values to a numpy array.
<pre>x = np.array(data.age.values) y = np.array(data.price.values)</pre>
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.
<pre>model = LinearRegression() model.fit(x.reshape((-1,1)), y) # x.reshape((-1,1) is convert numpy array to two dimensional array</pre>
We can find the best fit line for this data set if we want. And get the values of m (Slope) and b (Intercept).
<pre>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)</pre>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/389/1*7yYCNv6vw10cnXxfXHr2pg.png"><figcaption>Chart image by author</figcaption></figure>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.
<pre>year_seven = np.array([7]).reshape((-1,1)) # Predict the price model.predict(year_seven)</pre>
You’ll see the price after predict using the model is exactly the same as the previously calculated value that We using the formula.
<pre># array([133.40425532])</pre>
You can check the values of m and b by executing the variable in the notebook.
<pre>m # -20.691489361702125</pre>
<pre>b # 278.2446808510638</pre>
Happy Coding🎉
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=175225cb851b" width="1" height="1" alt="">

Math Behind Simple Linear Regression + Scikit Learn

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*87-IqvWbt7wWqbtQ4xEc9g.png"></figure>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 <a href="http://fostlet.herokuapp.com/">fostlet</a>. 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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*8JhkGJZF33BB1BJEMioxIw.gif"><figcaption>Final Chat App Output</figcaption></figure><h3>Installation</h3>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/400/1*lOd2MLcy9HxnaS6dxkye0w.png"></figure>First you should install <a href="https://deno.land/#installation">Deno</a> on your computer if you haven’t. Basically, you can install the setup by running a simple command.
<h3>Usage</h3>
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.
<h3>Step 1</h3>
Create a new file called index.html in a new folder and write the code below to create a simple user interface.
<a href="https://medium.com/media/357331de1b5e044e78b3495dedf274d0/href">https://medium.com/media/357331de1b5e044e78b3495dedf274d0/href</a>Also, add some styles using a style tag inside the index.html file. More customizations are up to you.
<a href="https://medium.com/media/072a247d99eeeadb108e78713a7ff927/href">https://medium.com/media/072a247d99eeeadb108e78713a7ff927/href</a><figure><img alt="" src="https://cdn-images-1.medium.com/max/742/1*yhMFcqlsGFphJBjPtZgvNg.png"><figcaption>Initial Overview</figcaption></figure>Okay, let’s do JavaScript, inside index.html create a new &lt;script&gt; tag to write JS for handle message submit, username submit, and WebSocket implementation on the client-side.
Select Dom elements and WebSocket
<pre>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');</pre>
Handle name form submission request
<pre>initForm.addEventListener('submit', (e) =&gt; { e.preventDefault(); name = initForm.name.value; msgRoom.style.display = "block" initForm.style.display = "none" });</pre>
Handle message form submission request and send to the server-side in JSON format.
<pre>msgForm.addEventListener('submit', e =&gt; { e.preventDefault(); const msg = msgForm.msg.value; ws.send(JSON.stringify({ name, msg })); msgForm.msg.value = ''; });</pre>
Output incoming message in the client side, with HTML elements.
<pre>const msgOutput = ({ data }) =&gt; { const { name, msg } = JSON.parse(data); const li = ` &lt;li&gt; &lt;div class="pname"&gt;${name}&lt;/div&gt; &lt;div class="pmsg"&gt;${msg}&lt;/div&gt; &lt;/li&gt; `; msgList.innerHTML += li; }</pre>
Finally, add event listener for WebSocket.
<pre>ws.addEventListener('message', msgOutput);</pre>
<h3>Step 2</h3>
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
<pre>import { WebSocket, isWebSocketCloseEvent } from "https://deno.land/std/ws/mod.ts"; import { v4 } from "https://deno.land/std/uuid/mod.ts";</pre>
Implement WebScoket
<pre>let sockets = new Map&lt;string, WebSocket&gt;();</pre>
Create TypeScript interface for event broadcaster function and define the function as eventBrodcaster.
<pre>interface BrodcastInterface { name: string, msg: string };</pre>
<pre>const eventBrodcaster = (obj: BrodcastInterface) =&gt; { sockets.forEach((ws: WebSocket) =&gt; { ws.send(JSON.stringify(obj)); }); }</pre>
Now create the connection to handle requests.
<pre>const connection = async (ws: WebSocket) =&gt; {</pre>
<pre> // New websocket and generate new user id const uid = v4.generate(); sockets.set(uid, ws);</pre>
<pre> for await (const ev of ws){</pre>
<pre> // remove socket if user close the tab or browser if(isWebSocketCloseEvent(ev)){ sockets.delete(uid); }</pre>
<pre> // broadcast the message that user sent if(typeof ev === 'string'){ let evObj = JSON.parse(ev); eventBrodcaster(evObj); } } }</pre>
Export the connection at the very bottom of the file.
<pre>export { connection };</pre>
<h3>Step 3</h3>
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.
<pre>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';</pre>
Setup server to listen port 3000 and add a console.log if you want.
<pre>const server = serve({ port: 3000 }); console.log("Chat app listening on port 3000");</pre>
Listen to the browser routes of the root directory and WebSocket directory.
<pre>for await (const req of server){ // serve index.html file - route / if(req.url === '/'){ req.respond({ status: 200, body: await Deno.open('./index.html') }); }</pre>
<pre> // 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) } } }</pre>
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.
<pre>deno run --allow-net --allow-read server.ts</pre>
Now you can see your simple chat app live on the port number 3000.
Happy Coding!🎉
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=3d7f9604d09d" width="1" height="1" alt="">

Deno WebSocket Realtime Chat App + TypeScript

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6OV5Jcp20Ph_rRfxF6ricQ.png"></figure>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.
<h3>Register with IBM Cloud</h3>
To Getting started with the Text to Speech model, You have to register with IBM Cloud. Go to <a href="https://cloud.ibm.com/registration">IBM Cloud</a> and create a new free account.
After that, you have to create lite plan instances of the model. To create that, go to the <a href="https://cloud.ibm.com/catalog/services/text-to-speech">Text to Speech model</a> 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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uBgb9cceMaEBtsandflegg.png"><figcaption>Text to Speech Model Credential Page</figcaption></figure><h3>Usage</h3>
First, have to install the ibm_watson on your computer.
<pre>pip install ibm_watson</pre>
If you are using Jupyter Notebook, add an exclamation mark before the command to act as if it is executed in the terminal.
<pre>!pip install ibm_watson</pre>
<h3>Authenticate</h3>
Import TextToSpeech model, Watson authenticator and authenticate with API key and the URL.
<pre>from ibm_watson import TextToSpeechV1 from ibm_cloud_sdk_core.authenticators import IAMAuthenticator</pre>
Specify the API Key and URL
<pre>url = '&lt;your-api-url&gt;' apiKey = '&lt;your-api-key&gt;'</pre>
<pre>authenticator = IAMAuthenticator(apiKey) tts = TextToSpeechV1(authenticator=authenticator) tts.set_service_url(url)</pre>
<h3>Setup Text to Speech</h3>
In this step, we’ll look at how to speak a text from string and text files.
<h4>From String</h4>
<pre>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)</pre>
In a while, it will generate that string to an audio file and export it as speech.mp3 at the root directory.
<h4>From Text File</h4>
<pre>with open('SpeechText.txt', 'r') as f: text = f.readlines()</pre>
Remove line breaks
<pre>text = [line.replace('\n', '') for line in text] text = ''.join(str(line) for line in text)</pre>
Export audio file
<pre>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)</pre>
<h3>Change Language and Voice (Optional)</h3>
If you want to change the voice or language, refer to this <a href="https://cloud.ibm.com/docs/text-to-speech?topic=text-to-speech-voices">IBM Languages and Voices</a> documentation.
For example, If I have chosen the German female voice de-DE_BirgitV3Voice, that code should be change like this.
<pre>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)</pre>
Eventually, You have created your own Speech-To-Text generating tool!🎉
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=43b61db39312" width="1" height="1" alt="">

Create a Synthesizes Natural Sounding Speech From Text Tool

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fAh5t2fLVQIUDWy1lGXJ6A.png"></figure>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.
<h3>Setup Django Project for Deployment</h3>
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
<pre>pip freeze &gt; requirements.txt</pre>
In my case, the example of the requirements.txt file.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/570/1*WGJWHpc8tP8RblzyvznquA.png"><figcaption>After run freeze command</figcaption></figure>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 <a href="https://pypi.org/project/pipreqs/">pipreqs</a>.
<pre>pip install pipreqs</pre>
Okay, then open your terminal and run this command.
<h3>Usage</h3>
<pre>pipreqs &lt;your-project-location&gt;</pre>
After the process, you can see it will output.
<pre>Successfully saved requirements file in &lt;your-project-location&gt;/requirements.txt</pre>
Okay, In my case, now the requirements.txt file contains I used dependencies in the project only. You will have your own dependency list.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/520/1*4pCct038y4Sl-TK93p9m0A.png"><figcaption>After run the pipreqs command</figcaption></figure>4. Add this code line in the settings.py file.
<pre>STATIC_ROOT = os.path.join(BASE_DIR, 'static')</pre>
5. Next, if you don’t have a Heroku account, create a new <a href="https://signup.heroku.com/">Heroku</a> account.
6. Download and install <a href="https://devcenter.heroku.com/articles/heroku-cli#download-and-install">Heroku CLI</a>.
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 this code line inside Procfile.
<pre>web: gunicorn &lt;your-project-name&gt;.wsgi</pre>
For more details, refer <a href="https://devcenter.heroku.com/articles/django-app-configuration#the-basics">django-heroku</a> documentation.
Okay, then you have to install two more libraries. This Procfile requires Gunicorn, the production web server that Heroku recommend for Django applications.
<pre>pip install gunicorn</pre>
<pre>pip install django-heroku</pre>
In the settings.py import django_heroku top of the file.
<pre>import django_heroku</pre>
Also, add this code line bottom of the settings.py file to activate django-heroku.
<pre>django_heroku.settings(locals())</pre>
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.)
<figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*VOwO2sEWIEOIYDXEV_7fbw.png"><figcaption>After add gunicorn and django-heroku libraries in to requirements.txt</figcaption></figure>8. Finally, run those commands one by one in the terminal on the project root directory.
<pre>git init git add . git commit -m "first commit"</pre>
<pre>heroku login heroku create &lt;your-app-name&gt; git push heroku master heroku open</pre>
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.
<pre>heroku run python manage.py migrate</pre>
Now your project is live on Heroku🎉
<h3>Optional</h3>
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.
<pre>DEBUG = False</pre>
<pre>ALLOWED_HOSTS = ['&lt;your-app-name&gt;.herokuapp.com', 'localhost', '127.0.0.1']</pre>
If you made those edits, then run this commands in the terminal
<pre>git add . git commit -m "settingspy edited" git push heroku master</pre>
Hope it will work!👏🎉
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=7b7ff2d29de8" width="1" height="1" alt="">

Django Easy Deployment On Heroku

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*V6R85q4jgqwM6RcgyshW7w.png"></figure>In this post, we’ll be settings up <a href="https://github.com/ThirashaPraween/RearGen">RearGen </a>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.
<ul>
<li>Running with native code base backend</li>
<li>Fast and easy</li>
<li>Build less than 5MB app</li>
<li>More customisation</li>
<li>Connection lost window</li>
<li>Pull and refresh facility</li>
<li>No SSL bypass</li>
<li>High quality rendering</li>
<li>Develop with HTML / CSS / JavaScript</li>
<li>Generating support</li>
<li>Live testing</li>
<li>Live installing</li>
<li>Recollecting feature</li>
<li>Full debugging details</li>
<li>External CSS and JavaScript libraries supported</li>
<li>Third party library support</li>
</ul>
<h3>Installation</h3>
First, you need to download the latest <a href="https://github.com/ThirashaPraween/RearGen">RearGen</a> 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 <a href="https://github.com/ThirashaPraween/RearGen#start-development">Start Development</a> 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 <a href="https://play.google.com/store/apps/details?id=tpw.creator.reargen">Play Store</a>.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/339/1*HyuTkrVD-ENtunJMA5RSAw.png"></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/339/1*dGyytoXYM2kzbuLhLJLxTQ.png"></figure><h3>Using custom template or library</h3>
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 <a href="https://github.com/ThirashaPraween/RearGen">RearGen</a> GitHub repository.
In the future, I will try to develop a material kit (with CSS and JS) for RearGen. That would be easy to develop the frontend and backend side of your app.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/350/1*OFueUxlpsVjnsyFtMaYU7A.png"></figure>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 <a href="https://github.com/ThirashaPraween/fornyKit">fornyKit</a> to your RearGen project.
Happy coding🎉!
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=98b4f7f3a8ad" width="1" height="1" alt="">

Build Your Android App with HTML, CSS, JS

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*beTUcu06clbefiMzJ_tCtQ.png"></figure>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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BKEoiEfmA6LClAFr_yJcbg.png"></figure>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.
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RsHQFaYEag5yBFMvWZc_cg.png"></figure>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 <a href="https://rolarbot.herokuapp.com/">RolarBot</a>.
Update
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3ST4wloleD834gsraTR1Jw.png"></figure>Now you can install the RolarBot android app from the play store. That mobile app is 20X faster than RolarBot web.
Install <a href="https://play.google.com/store/apps/details?id=rolarbot.thirashapw.ai">RolarBot </a>mobile app
Give your feedback after using the mobile app.
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=3832b2d5e689" width="1" height="1" alt="">