Docker have been an interesting and too useful tool in the industry. But as a fresher, it gets difficult to understand that “What is Docker?”, “What is it used for?” or “What is it’s advantages?”, etc. Let’s have a look and answer all these questions below.

What is Docker?

According to Wikipedia,

“Docker is a combination of PAAS which uses OS-virtualization to deliver software in packages called containers.”

Let’s understand in a more simpler way, while deploying or testing of any software we do it in a virtual machine or on testing machine (it can be the laptop of the tester or any other virtual environment) we need to install the required software or OS, it might happen that multiple version errors may occur. That’s where Docker container comes into play.

In Docker an image is created which is like a OS-virtualization that is it can run a different OS in your computer without requiring to install and setting up manually.

Writing a Dockerfile and producing the image will in solving the OS or software version errors and will also speed up setting up the resources.

What are the uses and advantages of Docker?

One of the advantages of Docker is it reduces the setting up time required to manually setup the virtual devices or test devices or any other devices.

The software versions error that may occur while using the software in multiple machines can be removed by just running the Dockerfile or the Docker image of the machine.

Handling the traffic or increasing/decreasing the running nodes on the server/Virtual machines gets much easier with Docker containers and Kubernetes or any other Docker manager service.

If any Docker container node gets down another Docker container node gets started and get setup without any manual interference using Kubernetes or any other Docker manager service. Which prevents the application from the downtime.

Maintenance of the application or software gets easier and less trouble some with Dockerization of the application.

Example of Dockerfile and Docker Image

Let’s have a look at the Dockerfile and understand few of it’s commands:

FROM ubuntu:18.04
COPY . /app
RUN make /app
CMD python /app/app.py

FROM Creates the layer from the given Docker image. Example:

FROM ubuntu:18.04

This creates a layer of ubuntu:18.04 Docker image.

2. COPY adds files from your Docker client’s current directory. Example:

COPY . ./app

Create a copy of all the items present in current directory of the machine to the ./app directory of the ubuntu:18.04.

3. RUN builds your application with make. It triggers while we build the docker image.

RUN make ./app

It run make command for the application in ./app directory of ubuntu:18.04 Docker Image.

4. CMD specifies what command to run within the container. It triggers while we launch the created docker image.

CMD python /app/app.py

After the Docker image ubuntu:18.04 has been launched it will run the application with the given command in CMD .

Extras:

To have a look at how Docker usecase for machine learning projects have visit at:

https://github.com/Darkshadow9799/Super-Resolution.git

Introduction to Docker was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.

NLP is a method or a way in which computer interprets the Human language are perform the task. Alexa, Siri, etc. are some of its example.

Let’s start with the Spam Classifier:

The spam classifier predicts whether received message is a ham or a spam.

Let’s start with the dataset: The dataset consists of 5572 messages and their labels which is either “ham” or “spam”.

import pandas as pd

messages = pd.read_csv(“SMSSpamClassifier”,sep=”\t”,names=[‘label’,’message’])

Now the labels needs to be converted in 0 and 1 labels which can be done using get_dummies() method of pandas library.

y = pd.getdummies(messages[‘labels’])

y = y.iloc[:1].values

Here, y wil contain 0 for “ham” labels and 1 for “spam” labels.

Now let’s look at independent data i.e. for x. For that 1st we have to clean the message data i.e. remove stopwords, lower string, group the same type words, etc. For all these we will use WordNetLemmatizer, the main reason of using the lemmatizer instead of stemming, it will provide meaning full words.

Now the code for it is:

import re

import nltk

import nltk.corpus import stopwords

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

corpus = []

for i in range(len(messages)):

review = re.sub(‘[^a-zA-Z]’,’ ‘,messages[‘message’][i])

review = review.lower()

review = review.split()

review = [lemmatizer.lemmaatizer(word) for word in review if not word in stopwords.words(‘english’)]

review = ‘ ‘.join(review)

corpus.append(review)

Here, corpus have all the sentences with clear data. The code above removes the stopwords, lowercase them and get all the important words that are required for prediction. Now we use Term Frequency and Inverse Term Frequency i.e. TfidfVectorizer to for the vector of words. The Tf-idf vector provide us with a vector of words and their importance.

Trending Bot Articles:

1. How Conversational AI can Automate Customer Service

2. Automated vs Live Chats: What will the Future of Customer Service Look Like?

3. Chatbots As Medical Assistants In COVID-19 Pandemic

4. Chatbot Vs. Intelligent Virtual Assistant — What’s the difference & Why Care?

from sklearn.feature_extraction.text import TfidfVectorizer

cv = TfidfVectorizer(max_features=5000)

x = cv.fit_transform(corpus).toarray()

The data is prepared in ‘x’ and now we can use it for training our model. Since Naïve Bayes algorithm works better for NLP we will use it for training our model.

from sklearn.model_selection import train_test_split

from sklearn.naive_bayes import MultinomialNB

from sklearn.metrics import accuracy_score

X_train, X_test, y_train, y_test = train_test_split(x, y, test_size = 0.20, random_state=0)

spam_detect_model = MultinomialNB().fit(X_train, y_train)

y_pred = spam_detect_model.predict(X_test)

print(accuracy_score(y_test,y_pred))

The model will give of accuracy of around 98%. To predict the new input we can use model.predict(cv.tranform(user_input).toarray()) and get the output for it.

All resources and code is present at:

Darkshadow9799/Sms-Spam-Classifier

To have a look for NLP description click here.

Don’t forget to give us your 👏 !

Spam Classifier: A Natural Language Processing Project was originally published in Chatbots Life on Medium, where people are continuing the conversation by highlighting and responding to this story.

In 1980’s, at that time the researches were not able to find deep neural network in ANN because we have to use sigmoid in each and every neuron as the ReLU was not invented. Because of sigmoid activation function we were facing a problem known as Vanishing Gradient Problem.

Let’s understand what actually it is.

Let the inputs be X1, X2 and X3 and the output be Yp and the weights be {W11, W12, W13}, {W21, W22, W23} and {W31, W32, W33} for inputs resp.

Now for 2nd layer to 3rd layer the weights be {O1, O2} resp.

To calculate W11 new formula is W11 new=W11 old -n (derivative of L w.r.t W11 old), where

i.e. Loss and Y is actual output.

The sigmoid function is given by

and the value of the sigmoid function is between 0 to 1. When we derivate the function the value comes between 0 to 0.25.

How??

Its derivative w.r.t x is

If we take the value of x to be 0 then f’(x) is 0.25 and when we take the value of x to be infinity then f’(x) is 0. This can be analysed using the graph given below where blue line represents sigmoid function and red line represents the derivative of sigmoid function.

This means as the layers increases the value of this derivative becomes less and less till the point where the value of old weights is approximately gets equals to the new weights.

For example, if we want to find W11 new and W11 old is 5 and n is 0.01 then we need derivative of L w.r.t W11 which is equal to derivative of L w.r.t O1 * derivative of O1 w.r.t W11.

Suppose the value of derivative of L w.r.t O1 is 0.25 and derivative of O1 w.r.t W11 is 0.02. Then the derivative of L w.r.t W11 is 0.05, which makes the new values as 4.9995 which is approximately 5.

This type of problem in Deep learning is considered as Vanishing Gradient Descent.

Vanishing Gradient Problem in Deep Learning was originally published in Analytics Vidhya on Medium, where people are continuing the conversation by highlighting and responding to this story.