1623161484

# 5 Amazing NLP Use-cases using Real Dataset to Add To Your Portfolio

In this video, I have covered the 5 NLP use0cass using real-world datasets. These use-cases would be good to learn the NLP concepts and to add some amazing projects to your portfolio

02:15 - Analyzing Impact of Tweet
Dataset - https://www.kaggle.com/alaix14/bitcoin-tweets-20160101-to-20190329

05:46 - Sentiment Analysis on Amazon Review Dataset
Dataset - https://nijianmo.github.io/amazon/index.html

09:38 - Text Classification - Categorize Stack overflow Posts
Dataset - https://www.kaggle.com/imoore/60k-stack-overflow-questions-with-quality-rate

13:05 -Identify Sarcasm

14:58 - Fake News Detection
Dataset - https://www.kaggle.com/clmentbisaillon/fake-and-real-news-dataset
To Subscribe:

#data-science #developer

1645534030

## matrix multiplication in python user input

Given two user input matrix. Our task is to display the addition of two matrix. In these problem we use nested List comprehensive.

matrix multiplication in python user input

## Algorithm

Step1: input two matrix.

Step 2: nested for loops to iterate through each row and each column.

Step 3: take one resultant matrix which is initially contains all 0. Then we multiply each row elements of first matrix with each elements of second matrix, then add all multiplied value. That is the value of resultant matrix.

## Example Code

``````# Program to multiply two matrices
A=[]
n=int(input("Enter N for N x N matrix: "))
print("Enter the element ::>")
for i in range(n):
row=[]                                      #temporary list to store the row
for j in range(n):
row.append(int(input()))           #add the input to row list
A.append(row)                      #add the row to the list
print(A)
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
#Display the 2D array
print("Display Array In Matrix Form")
for i in range(n):
for j in range(n):
print(A[i][j], end=" ")
print()                                        #new line
B=[]
n=int(input("Enter N for N x N matrix : "))           #3 here
#use list for storing 2D array
#get the user input and store it in list (here IN : 1 to 9)
print("Enter the element ::>")
for i in range (n):
row=[]                                      #temporary list to store the row
for j in range(n):
row.append(int(input()))           #add the input to row list
B.append(row)                       #add the row to the list
print(B)
# [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
#Display the 2D array
print("Display Array In Matrix Form")
for i in range(n):
for j in range(n):
print(B[i][j], end=" ")
print()
result = [[0,0,0], [0,0,0], [0,0,0]]
for i in range(len(A)):
for j in range(len(B[0])):
for k in range(len(B)):
result[i][j] += A[i][k] * B[k][j]
print("The Resultant Matrix Is ::>")
for r in result:
print(r) ``````

## Output

``````Enter N for N x N matrix: 3
Enter the element ::>
2
1
4
2
1
2
3
4
3
[[2, 1, 4], [2, 1, 2], [3, 4, 3]]
Display Array In Matrix Form
2 1 4
2 1 2
3 4 3
Enter N for N x N matrix : 3
Enter the element ::>
1
2
3
4
5
6
7
8
9
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
Display Array In Matrix Form
1 2 3
4 5 6
7 8 9
The Resultant Matrix Is ::>
[34, 41, 48]
[20, 25, 30]
[40, 50, 60]``````

https://www.pakainfo.com/python-program-multiplication-of-two-matrix-from-user-input/

1623161484

## 5 Amazing NLP Use-cases using Real Dataset to Add To Your Portfolio

In this video, I have covered the 5 NLP use0cass using real-world datasets. These use-cases would be good to learn the NLP concepts and to add some amazing projects to your portfolio

02:15 - Analyzing Impact of Tweet
Dataset - https://www.kaggle.com/alaix14/bitcoin-tweets-20160101-to-20190329

05:46 - Sentiment Analysis on Amazon Review Dataset
Dataset - https://nijianmo.github.io/amazon/index.html

09:38 - Text Classification - Categorize Stack overflow Posts
Dataset - https://www.kaggle.com/imoore/60k-stack-overflow-questions-with-quality-rate

13:05 -Identify Sarcasm

14:58 - Fake News Detection
Dataset - https://www.kaggle.com/clmentbisaillon/fake-and-real-news-dataset
To Subscribe:

#data-science #developer

1624516500

## Inside ABCD, A Dataset To Build In-Depth Task-Oriented Dialogue Systems

According to a recent study, call centre agentsâ€™ spend approximately 82 percent of their total time looking at step-by-step guides, customer data, and knowledge base articles.

Traditionally, dialogue state tracking (DST) has served as a way to determine what a caller wants at a given point in a conversation. Unfortunately, these aspects are not accounted for in popular DST benchmarks. DST is the core part of a spoken dialogue system. It estimates the beliefs of possible userâ€™s goals at every dialogue turn.

To reduce the burden on call centre agents and improve the SOTA of task-oriented dialogue systems, AI-powered customer service company ASAPP recently launched an action-based conversations dataset (ABCD). The dataset is designed to help develop task-oriented dialogue systems for customer service applications. ABCD consists of a fully labelled dataset with over 10,000 human dialogues containing 55 distinct user intents requiring sequences of actions constrained by company policies to accomplish tasks.

The dataset is currently available on GitHub.

#developers corner #asapp abcd dataset #asapp new dataset #build enterprise chatbot #chatbot datasets latest #customer support datasets #customer support model training #dataset for chatbots #dataset for customer datasets

1598709780

## 8 Open-Source Tools To Start Your NLP Journey

Teaching machines to understand human context can be a daunting task. With the current evolving landscape, Natural Language Processing (NLP) has turned out to be an extraordinary breakthrough with its advancements in semantic and linguistic knowledge. NLP is vastly leveraged by businesses to build customised chatbots and voice assistants using its optical character and speed recognition techniques along with text simplification.

To address the current requirements of NLP, there are many open-source NLP tools, which are free and flexible enough for developers to customise it according to their needs. Not only these tools will help businesses analyse the required information from the unstructured text but also help in dealing with text analysis problems like classification, word ambiguity, sentiment analysis etc.

Here are eight NLP toolkits, in no particular order, that can help any enthusiast start their journey with Natural language Processing.

#### 1| Natural Language Toolkit (NLTK)

About: Natural Language Toolkit aka NLTK is an open-source platform primarily used for Python programming which analyses human language. The platform has been trained on more than 50 corpora and lexical resources, including multilingual WordNet. Along with that, NLTK also includes many text processing libraries which can be used for text classification tokenisation, parsing, and semantic reasoning, to name a few. The platform is vastly used by students, linguists, educators as well as researchers to analyse text and make meaning out of it.

#developers corner #learning nlp #natural language processing #natural language processing tools #nlp #nlp career #nlp tools #open source nlp tools #opensource nlp tools

1593056092

## Top 6 Python Packages You Should be Using in Every Django Web App

There are countless Python packages easily added to any project. But there are some packages you can't help but use in every Django web app because they've proven to be extremely beneficial and time-saving.

We decided to focus on those packages, the ones you'll end up installing regularly, and explain the installation and configurations needed to get them up and running.

While some Python packages offer cool functionality needed for one specific project, the packages discussed below are the bread-and-butter of the Django packages.

Django Web Framework

But we can't jump into Django packages by talking about the Django web framework.

A web framework is comprised of modules or packages that allow developers to quickly write web applications without having to handle the precise details of the protocol and other web app management.

Django is considered a full-stack web framework in which a database, application server, template engine, authentication module, and dispatcher are all neatly combined to create a high-level framework. These individual components are included upon package installation and often just need some minor configurations for them to function correctly.

macOS Terminal

``(env)User-Macbook:env user\$ pip install django``

Windows Command Prompt

``(env)C:\Users\Owner\desktop\env> pip install django``

At the time of this article, the latest version of Django is 3.0.8. To install the latest version, all you need is the command `pip install django`.

If you wish to install a different version, then specify the version number as demonstrated in the command `pip install django==2.1.15`. Please note that there are two equal signs after the package name, not one.

Once the installation is complete, you will need to start configuring your Django web app with a project and an application. If you want to jump right into building your Django web app, check out the quick start guides to Django Installation and Django Configuration. Or if you are just getting started and need a step-by-step tutorial, see the Beginner's Guide to Django Web Apps

But we are here to talk about Python Packages meant for Django web apps, not basic Django configurations so we'll keep moving.

We have a lot to cover.

1. Django TinyMCE4 Lite
2. Pillow
3. Django Crispy Forms
4. Django Tables
5. Django Filter
6. Python Decouple

(1) Django TinyMCE4 Lite

macOS Terminal

``(env)User-Macbook:mysite user\$ pip install django-tinymce4-lite``

Windows Command Prompt

``(env) C:\Users\Owner\Desktop\Code\env\mysite>pip install django-tinymce4-lite``

Once you have finished the basic configurations of your web app, you can install a cool Python package named django-tinymce4-lite. This package is actually a smaller version of the Django application django-tinymce4 that contains a widget to render Django form fields as TinyMCE editors.

TinyMCE is a WYSIWYG ("what you see is what you get") text editor that converts HTML elements into editor instances or "plain text".  This python package is highly recommended if you are looking to create a blog as you can easily edit text that is then formatted to HTML within the actual template.

env > mysite > mysite > settings.py

``````INSTALLED_APPS = [
...
...
'tinymce',
]

TINYMCE_DEFAULT_CONFIG = {
'height': 400,
'width': 1000,
'cleanup_on_startup': True,
'custom_undo_redo_levels': 20,
'selector': 'textarea',
'browser_spellcheck': 'True',
'theme': 'modern',
'plugins': '''
table code lists fullscreen  insertdatetime  nonbreaking
visualchars code fullscreen autolink lists  charmap print  hr
anchor pagebreak
''',
'toolbar1': '''
fullscreen preview bold italic underline | fontselect,
fontsizeselect  | forecolor backcolor | alignleft alignright |
aligncenter alignjustify | indent outdent | bullist numlist table |
| link image media | codesample
''',
'toolbar2': '''
visualblocks visualchars |
charmap hr pagebreak nonbreaking anchor |  code |
''',
'statusbar': True,
}``````

After installation, you will need to add `tinymce` to the list of installed apps in the settings file then add the default configurations below.  The default configurations define the height, weight, spellcheck, and toolbars.

env > mysite > mysite > urls.py

``````"""mysite URL Configuration

https://docs.djangoproject.com/en/2.1/topics/http/urls/
Examples:
Function views
1. Add an import:  from my_app import views
2. Add a URL to urlpatterns:  path('', views.home, name='home')
Class-based views
1. Add an import:  from other_app.views import Home
2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
Including another URLconf
1. Import the include() function: from django.urls import include, path
2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
"""
from django.urls import path, include

urlpatterns = [
path('', include ('main.urls')),

]``````

Then add the TinyMCE path to the project URLs.

env > mysite > main > models.py

``````from django.db import models
from tinymce import HTMLField

class MyModel(models.Model):
...
content = HTMLField()``````

Finally, you can quickly add TinyMCE to the Django model by importing `HTMLField` at the top of the page then calling it in the model field. If you are unsure of how to use Django models, check out the article, How to use Django Models for more information.

(2) Pillow

macOS Terminal

``(env)User-Macbook:mysite user\$ pip install Pillow``

Windows Command Prompt

``(env) C:\Users\Owner\Desktop\Code\env\mysite>pip install Pillow``

So, this package is not specific to Django but is needed for image and file uploads to work correctly in a Django project.  If you are looking to have a media upload field in your Django model for let's say an article cover image, you need to install Pillow. It's a Python Imaging Library fork for uploading files correctly.

env > mysite > mysite > settings.py

``````MEDIA_URL = '/media/'

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')``````

Once installed, you need to add a media folder URL and ROOT directory to your settings file.

env > mysite > mysite > urls.py

``````from django.contrib import admin
from django.urls import path, include
from django.conf import settings #add this
from django.conf.urls.static import static #add this

urlpatterns = [
path('', include ('main.urls')),
]

urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)``````

Then you need to add the necessary imports at the top of your project's URL file and specify the URL pattern to the media folder. Keep in mind that the media upload will not work in production given the if condition. You will need to reconfigure your media upload location when you are ready to deploy.

env > mysite > main > models.py

``````from django.db import models

class MyModel(models.Model):
...

Now to upload an image, go to your models file and add an `ImageField` with the upload location as` 'images/'`. The uploaded images will then be added to a media  > images folder that will automatically be created upon the upload.

For more information about correctly creating a model, accessing the upload location in the Django admin, and rendering the model in a template, refer to How to use Django Models.

(3) Django Crispy Forms

macOS Terminal

``(env)User-Macbook:mysite user\$ pip install django-crispy-forms``

Windows Command Prompt

``(env) C:\Users\Owner\desktop\code\env\mysite>pip install django-crispy-forms``

Let's talk about Django forms. Their functionality is great but their appearance isn't the best. You can choose to install django-crispy-forms in your project to quickly solve this issue.

env > mysite > mysite > settings.py

``````INSTALLED_APPS = [
...
'crispy_forms',
]

CRISPY_TEMPLATE_PACK = 'uni_form'``````

For it to function correctly, you will need to go to the settings file and add `crispy_forms` to the installed apps list. Keep in mind that there is an underscore between crispy and forms.

Then you need to specify the crispy template pack. The one listed below is the default but if you are using the Bootstrap CSS framework, check out how to integrate Bootstrap with django-crispy-forms

env > mysite > main > templates > main > contact.html

``````{% load crispy_forms_tags %}

<form method="post">
{% csrf_token %}
{{form|crispy}}
<button type="submit">Submit</button>
</form>``````

The package django-crispy-forms is added to the project in the form of a filter added within the Django template language `{{form}}`. This format will not only call all of the form fields but also format each field according to the crispy form template pack specified in the settings.

Refer to the article Render Forms with Django Crispy Forms for more information regarding the form rendering process using crispy forms and the article Build a Django Contact Form with Email Backend for more general information on how to build a Django form.

(4) Django Tables

macOS Terminal

``(env)User-Macbook:mysite user\$ pip install django-tables2``

Windows Command Prompt

``(env) C:\Users\Owner\desktop\code\env\mysite>pip install django-tables2``

Now let's say you want to create a dynamic table in your Django project that connects to a model. Install django-tables2, a Django-specific package for table rendering.

env > mysite > mysite > settings.py

``````INSTALLED_APPS = [
...
'django_tables2',
]``````

Add Django tables to the installed apps.

env > mysite > main > models.py

``````from django.db import models

class MyModel(models.Model):
name = models.CharField(max_length=100, verbose_name="full name")
email = models.EmailField(max_length=200)
``````

Then create the model you wish to use in the table.

After you have created the model, you will need to run the commands `python manage.py makemigrations` and `python manage.py migrate` to add the model to the database and add your model objects via the Django admin. For more instruction, see How to Use Django Models

env > mysite > main > (New File) tables.py

``````import django_tables2 as tables
from .models import MyModel

class MyTable(tables.Table):
class Meta:
model = MyModel
fields = ("name", "email", )``````

Now, create a new file called tables.py in the application folder, main, and import `tables` from `django_tables2` at the top of the file. Then create a class that specifies the model and field names.

env > mysite > main > views.py (Class-based views)

``````...
from django_tables2 import SingleTableView

from .models import MyModel
from .tables import MyTable

class ListView(SingleTableView):
model = MyModel
table_class = MyTable
template_name = 'main/table.html'``````

If you are looking to use class-based views, go to the views file and add the view class specifying the model, table, and template. Again, you will need to import the necessary variables from their appropriate files at the top of the file.

env > mysite > main > urls.py (Class-based views)

``````from django.urls import path
from . import views

app_name = "main"

urlpatterns = [
path("table", views.ListView.as_view()),
]``````

Then make sure there is a tables URL in the app urls.py file. If you are looking to learn more about class-based views, check out the article Django Class-based Views.

env > mysite > main > views.py (Function-based views)

``````...
from django_tables2 import SingleTableView

from .models import MyModel
from .tables import MyTable

def list(request):
model = MyModel.objects.all()
table = MyTable(model)
return render(request=request, template_name="main/table.html", context={"model":model, "table":table})``````

Or you can choose to do function-based views in the views.py file. Either one will work, but the format is different.

env > mysite > main > urls.py (Function-based views)

``````from django.urls import path
from . import views

app_name = "main"

urlpatterns = [
path("table", views.list, name="list"),
]``````

Then add the table URL in the app urls.py file.

env > mysite > main > templates > main > (New File) table.html

``````{% load render_table from django_tables2 %}

<div>
{% render_table table %}
</div>``````

With the views and URLs configured, you can render the table in the template by loading in `render_table from django_tables2` at the top of the file then calling `render_table` and the context of the table passed in the view.

By default, the class-based view passes the table context as just `table`, and in the function-based view, we also chose to specify the context of the table as `table`

If you want to add Bootstrap CSS to the table:

env > mysite > main > tables.py

``````import django_tables2 as tables
from .models import MyModel

class MyTable(tables.Table):
class Meta:
model = MyModel
template_name = "django_tables2/bootstrap4.html"
fields = ("name", "email",)``````

Add a template name to the tables.py file connecting to the Bootstrap template. This and other template files can be found in the Lib > site-packages > django_tables2 > templates > django_tables2 folder of your project.

env > mysite > main > templates > main > (New File) table.html

``````{% extends "main/header.html" %}

{% block content %}

{% load render_table from django_tables2 %}

<div class="container">
{% render_table table %}
</div>

{% endblock %}``````

Then you can extend to a header that loads in the Bootstrap CDNs. This is the easiest way of adding Bootstrap to all of your templates using the same piece of code.

If you are unsure of how to use the extends tag with the Bootstrap CDNs, check out the Django extends tag and block content section in the Beginner's Guide to Django Web Apps

(5) Django Filter

macOS Terminal

``(env)User-Macbook:mysite user\$  pip install django-filter``

Windows Command Prompt

``(env) C:\Users\Owner\desktop\code\env\mysite>  pip install django-filter``

Now that you have a table, you probably want the ability to search for specific content within the rows and filter the table by its results. The django-filter package can easily be used on top of the django-tables2 package to accomplish this.

env > mysite > mysite > settings.py

``````INSTALLED_APPS = [
...
'django_filters',
]``````

Add Django filters to the installed apps. Note that is `django_filters` not `django_filter`.

env > mysite > main > (New File) filters.py

``````import django_filters
from .models import MyModel

class MyFilter(django_filters.FilterSet):
name = django_filters.CharFilter(lookup_expr='icontains')

class Meta:
model = MyModel
fields = {'name', 'email'}``````

Now, create a new file called filters.py in the application folder, main, and import django_filters. Then list the model and the model fields you wish to filter by.

You can also choose to add `django_filters.CharFilter` to the class. In the example above, the filter displays any rows where the name column contains the query specified.

You can also choose to do `django_filters.CharFilter(lookup_expr='iexact')` if you are looking to filter only by an exact query match.

env > mysite > main > views.py (Class-based views)

``````...
from django_tables2 import SingleTableMixin
from django_filters.views import FilterView

from .models import MyModel
from .tables import MyTable
from .filters import MyFilter

class ListView(SingleTableMixin, FilterView):
model = MyModel
table_class = MyTable
template_name = 'main/table.html'
filterset_class = MyFilter``````

Then for a class-based view, import FilterView from django_filters.views at the top of the file and change django_tables2 import from `SingleTableView` to `SingleTableMixin`. You will also need to import your custom filter from the filter.py file.

In the class view, `ListView` will now inherit `SingleTableMixin` and `FilterView` and list the `filterset_class` as the custom filter within it.

env > mysite > main > templates > main > table.html

``````{% load render_table from django_tables2 %}

<div>
<br>
<form action="" method="GET">
{{filter.form}}
<button type="submit">Filter</button>
</form>
<br>
{% render_table table %}
</div>
``````

With class-based views, the URL will stay the same but you will need to add a form HTML element and the Django Template language calling the filter and the form within the template. You also need a submit button within the form to submit your filter queries. Nothing changes about the way the table renders.

env > mysite > main > views.py (Function-based views)

``````...
from django_tables2.views import SingleTableMixin
from django_filter import FilterView

from .models import MyModel
from .tables import MyTable

def list(request):
model = MyModel.objects.all()
filterset_class = MyFilter(request.GET, model)
table = MyTable(filterset_class.qs)
return render(request=request, template_name="main/table.html", context={"model":model, "table":table, "filterset_class":filterset_class})``````

If using function-based views, make the same imports and the class-based views, then create an instance of the MyFilter class and pass in a GET request and model as arguments. Pass in the `filterset_class` as a queryset argument in the table then lists the `filterset_class` as context in the return render.

env > mysite > main > templates > main > table.html

``````{% load render_table from django_tables2 %}

<div>
<br>
<form action="" method="GET">
{{filterset_class.form}}
<button type="submit">Filter</button>
</form>
<br>
{% render_table table %}
</div>
``````

With function-based views, you will need to specify the `filterset_class`, or the context declared, as the filter on the form. Everything else is the same format as the class-based template.

If you are looking to style the form, either scroll back up to the Django Crispy Forms section or click at the article mentioned earlier, Render Forms with Django Crispy Forms.

(6) Python Decouple

macOS Terminal

``(env)User-Macbook:mysite user\$ pip install python-decouple``

Windows Command Prompt

``(env) C:\Users\Owner\desktop\code\env\mysite> pip install python-decouple``

The last and arguably most important Python package we will discuss is python-decouple. This package hides your sensitive configuration keys and information from hackers. It was created for Django but it is now considered a "generic tool" for separating configuration settings.

env > mysite > (New File) .env

``````SECRET_KEY =sdjioerb43buobnodhioh4i34hgip
DEBUG =True``````

env > mysite > mysite > settings.py

``````from decouple import config

SECRET_KEY = config('SECRET_KEY')
DEBUG = config('DEBUG', cast=bool)``````

Create a new file named .env in the project folder then import config in the settings.py file. Then transfer all of the configuration settings and variables you wish to hide to the .env file and call each variable using the python-decouple format of `config('variable')`.

#programming #django #python