DEV Community: Amit Chaudhary

A Visual Guide to Regular Expression

Amit Chaudhary — Fri, 23 Oct 2020 10:34:52 +0000

It's a common task in NLP to either check a text against a pattern or extract parts from the text that matches a certain pattern. A regular expression or "regex" is a powerful tool to achieve this.

While powerful, regex can feel daunting as it comes with a lot of features and sub-parts that you need to remember.

In this post, I will illustrate the various concepts underlying regex. The goal is to help you build a good mental model of how a regex pattern works.

Mental Model

Let's start with a simple example where we are trying to find the word 'cool' in the text.

With regex, we could simply type out the word 'cool' as the pattern and it will match the word.

'cool'

While regex matched our desired word 'cool', the way it operates is not at the word level but the character level. This is the key idea.

Key Idea: Regex works at the character-level, not word-level.

The implication of this is that the regex r'cool' would match the following sentences as well.

Basic Building Blocks

Now that we understand the key idea, let's understand how we can match simple characters using regex.

a. Specific character

We can simply specify the character in the regular expression and it will match all instances in the text.

For example, a regular expression given below will match all instances of 'a' in the text. You can use any of the small and capital alphabets.

'a'

You can also use any digits from 0 to 9 and it will work as well.

'3'

Note that regex is case-sensitive by default and thus the following regex won't match anything.

'A'

b. White space character

We can detect special characters such as whitespace and newlines using special escape sequences.

Besides the common ones above, we have:

\r for carriage return
\f for form feed
\e for escape.

c. Special sequences

Regex provides a bunch of built-in special symbols that can match a group of characters at once. These begin with backslash \.

Pattern: `\d`

It matches any single-digit number between 0 to 9.

Notice that matches are single digit. So we have 4 different matches below instead of a single number 18.04.

Pattern: \s

It matches any whitespace character (space, tab or newline).

Pattern: \w

It matches any of the small alphabets(a to z), capital alphabets(A to Z), digits (0 to 9), and underscore.

Pattern: .

It matches any character except the new line (\n).

import re

>>> re.findall(r'.', 'line 1\nline2')
['l', 'i', 'n', 'e', ' ', '1', 'l', 'i', 'n', 'e', '2']

Pattern: Negations

If you use the capitalized versions of the patterns above, they act as negation.

For example, if "\d" matched any digits from 0 to 9, then "\D" will match anything except "0 to 9".

d. Character sets

These are patterns starting with [ and ending with ] and specify the characters that should be matched enclosed by brackets.

For example, the following pattern matches any of the characters 'a', 'e', 'i', 'o', and 'u'.

You can also replicate the functionality of \d using the below pattern. It will match any digits between 0 to 9.

Instead of specifying all the digits, we can use - to specify only start and end digits. So, instead of [0123456789], we can do:

For example, [2-4] can be used to match any digits between 2 to 4 i.e. (2 or 3 or 4).

You can even use the special characters we learned previously inside the brackets. For example, you can match any digit from 0 to 9 or whitespace as:

Below, I have listed some useful common patterns and what they mean.

e. Anchors

Regex also has special handlers to make the pattern only match if it's at the start or end of the string.

We can use the ^ anchor to match patterns only at the start of a line. For example:

Similarly, we can use the $ anchor after the character to match patterns only if it's the end of the line. For example:

f. Escaping metacharacters

Consider a case where we want to exactly match the word "Mr. Stark".

If we write a regex like Mr. Stark, then it will have an unintended effect. Since we know dot has a special meaning in a regex.

So, we should always escape the special metacharacters like ., $ etc. if our goal is to match the exact character itself.

Here is the list of metacharacters that you should remember to escape if you're using them directly.

^ $ . * + ? { } [ ] \ | ( )

Repetition of basic blocks

Now that we can pattern match any characters, we could repeat things and start building more complicated patterns.

a. Naive repetition

Using only what we have learned so far, a naive way would be to just repeat the pattern. For example, we can match two-digit numbers by just repeating the character-level pattern.

\d\d

b. Quantifiers

Regex provides special quantifiers to specify different types of repetition for the character preceding it.

i. Fixed repetition

We can use the {...} quantifier to specify the number of times a pattern should repeat.

For example, the previous pattern for matching 2-digit number can be recreated as:

You can also specify a range of repetitions using the same quantifier. For example, to match from 2-digit to 4-digit numbers, we could use the pattern:

When applied to a sentence, it will match both 4-digit and 2-digit numbers.

Note:

There should not be any space between minimum and maximum count For example, \d{2, 4} doesn't work.

ii. Flexible quantifiers

Regex also provides quantifiers "*", "+" and "?" using which you can specify flexible repetition of a character.

0 or 1 times: ?

The ? quantifier matches the previous character if it repeats 0 or 1 times. This can be useful to make certain parts optional.

For example, let's say we want to match both the word "sound" and "sound" where "s" is optional. Then, we can use the ? quantifier that matches if a character repeats 0 or 1 times.
one or more times: +

The + quantifier matches the previous character if it repeats 1 or more times.

For example, we could find numbers of any arbitrary length using the regex \d+.
zero or more times: *

The * quantifier matches the previous character if it repeats zero or more times.

Usage in Python

Python provides a module called "re" in the standard library to work with regular expression.

Need for raw strings

To specify a regular expression in Python, we precede it with r to create raw strings.

pattern = r'\d'

To understand why we precede with r, let's try printing the expression \t without **r**.

>>> pattern = '\t'
>>> print(pattern)

You can see how when we don't use raw string, the string \t is treated as the escape character for tab by Python.

Now let's convert it into raw string. We get back whatever we specified.

>>> pattern = r'\t'
>>> print(pattern)
\t

Using re module

To use re module, we can start by importing the re module as:

import re

1. re.findall

This function allows us to get all the matches as a list of strings.

import re
re.findall(r'\d', '123456')

['1', '2', '3', '4', '5', '6']

2. re.match

This function searches for a pattern at the beginning of the string and returns the first occurrence as a match object. If the pattern is not found, it returns None.

import re

match = re.match(r'batman', 'batman is cool')
print(match)

<re.Match object; span=(0, 6), match='batman'>

With the match object, we can get the matched text as

print(match.group())

batman

In a case where our pattern is not at the start of the sentence, we will not get any match.

import re

match = re.match(r'batman', 'The batman is cool')
print(match)

None

3. re.search

This function also finds the first occurrence of a pattern but the pattern can occur anywhere in the text. If the pattern is not found, it returns None.

import re

match = re.search(r'batman', 'the batman is cool')
print(match.group())

batman

References

A.M. Kuchling, "Regular Expression HOWTO - Python 3.9.0 documentation"

Connect

If you enjoyed the blog post, feel free to connect with me on Twitter where I share new blog posts every week.

VSCode on Google Colab

Amit Chaudhary — Mon, 07 Sep 2020 06:27:56 +0000

I recently discovered a way to setup VSCode on Google Colab and use it as an editor to write code and run experiments on the Colab VM.

With this setup, you can still prototype in the Colab Notebook while also using VSCode for all the advantages of an full-fledged code editor. Here is how you can replicate my setup.

Steps

I have described the steps in details below. After going through all the steps, please use this colab notebook to try it out directly.

First, we will install the code-server package to run VSCode editor as a web app. Copy and run the following command on colab to install code-server.
```
!curl -fsSL https://code-server.dev/install.sh | sh
```
After the installation is complete, we will expose a random port 9000 to an external URL we can access using the pyngrok package. To install pyngrok, run
```
!pip install -qqq pyngrok
```
Then, run the following following command to get a public ngrok URL. This will be the URL we will use to access VSCode.
```
from pyngrok import ngrok
url = ngrok.connect(port=9000)
print(url)
```
Now, we will start the VSCode server in the background at port 9000 without any authentication using the following command.
```
!nohup code-server --port 9000 --auth none &
```
Now, you can access the VSCode interface at the URL you got from step 3. The interface and functionality is same as the desktop version of VSCode.

Tips

All the keyword shortcuts of regular VSCode works with this. For example, you can use Ctrl + Shift + P to open a popup for various actions.

To open a terminal, you can use the shortcut Ctrl + Shift + `.

To get python code completions, you can install the Python(ms-python) extension from the extensions page on the left sidebar.

The Colab interface is still usable as a notebook and regular functions to upload and download files and mount with Google Drive. Thus, you get the benefits of both a notebook and a code editor.

References

Connect

If you enjoyed the blog post, feel free to connect with me on Twitter where I share new blog posts every week.

Text Data Augmentation with MarianMT

Amit Chaudhary — Mon, 07 Sep 2020 06:25:44 +0000

Hugging Face recently released 1008 translation models for almost 140 languages on their model hub.

These models were originally trained by Jörg Tiedemann of the Language Technology Research Group at the University of Helsinki. They were trained on the Open Parallel Corpus(OPUS) using a neural machine translation framework called MarianNMT.

In this post, I will explain how you can use the MarianMT models to augment data text data.

Back Translation

We will use a data augmentation technique called "Back Translation". In this, we take an original text written in English. Then, we convert it into another language (eg. French) using MarianMT. We translate the French text back into English using MarianMT. We keep the back-translated English text if it is different from the original English sentence.

Augmentation Process

First, we need to install Hugging Face transformers and Moses Tokenizers with the following command

pip install -U transformers 
pip install mosestokenizer

After installation, we can now import the MarianMT model and tokenizer.

from transformers import MarianMTModel, MarianTokenizer

Then, we can create a initialize the model that can translate from English to Romance languages. This is a single model that can translate to any of the romance languages()

target_model_name = 'Helsinki-NLP/opus-mt-en-ROMANCE'
target_tokenizer = MarianTokenizer.from_pretrained(target_model_name)
target_model = MarianMTModel.from_pretrained(target_model_name)

Similarly, we can initialize models that can translate Romance languages to English.

en_model_name = 'Helsinki-NLP/opus-mt-ROMANCE-en'
en_tokenizer = MarianTokenizer.from_pretrained(en_model_name)
en_model = MarianMTModel.from_pretrained(en_model_name)

Next, we write a helper function to translate a batch of text given the machine translation model, tokenizer and the target romance language.

def translate(texts, model, tokenizer, language="fr"):
    # Prepare the text data into appropriate format for the model
    template = lambda text: f"{text}" if language == "en" else f"{language}<< {text}"
    src_texts = [template(text) for text in texts]

    # Tokenize the texts
    encoded = tokenizer.prepare_seq2seq_batch(src_texts)

    # Generate translation using model
    translated = model.generate(**encoded)

    # Convert the generated tokens indices back into text
    translated_texts = tokenizer.batch_decode(translated, skip_special_tokens=True)

    return translated_texts

Next, we will prepare a function to use the above translate() function to perform back translation.

def back_translate(texts, source_lang="en", target_lang="fr"):
    # Translate from source to target language
    fr_texts = translate(texts, target_model, target_tokenizer, 
                         language=target_lang)

    # Translate from target language back to source language
    back_translated_texts = translate(fr_texts, en_model, en_tokenizer, 
                                      language=source_lang)

    return back_translated_texts

Now, we can perform data augmentation using back-translation from English to Spanish on a list of sentences as shown below.

en_texts = ['This is so cool', 'I hated the food', 'They were very helpful']

aug_texts = back_translate(en_texts, source_lang="en", target_lang="es")
print(aug_texts)

["Yeah, it's so cool.", "It's the food I hated.", 'They were of great help.']

Similarly, we can perform augmentation using English to French as shown below with the exact same helper method.

en_texts = ['This is so cool', 'I hated the food', 'They were very helpful']
aug_texts = back_translate(en_texts, source_lang="en", target_lang="fr")

print(aug_texts)

["It's so cool.", 'I hated food.', "They've been very helpful."]

Chained Back Translation

You can also run back translation in a chain to get more diversity. For example, English -> Spanish -> English -> French -> English

en_texts = ['This is so cool', 'I hated the food', 'They were very helpful']

aug1_texts = back_translate(en_texts, source_lang="en", target_lang="es")
aug2_texts = back_translate(aug1_texts, source_lang="en", target_lang="fr")

print(aug2_texts)

["Yeah, that's cool.", "It's the food I hated.", 'They were of great help.']

Available Models

Here are language codes for a subset of major romance language that you can use above.

Language	French	Spanish	Italian	Portuguese	Romanian	Catalan	Galician	Latin
Code	fr	es	it	pt	ro	ca	gl	la

Language	Walloon	Occitan (post 1500)	Sardinian	Aragonese	Corsican	Romansh
Code	wa	oc	sn	an	co	rm

To view all available language codes, you can run

target_tokenizer.supported_language_codes

Alternative Applications

Besides data augmentation, the back translation process can also be used for text paraphrasing.

Similarly, we can also use it as an adversarial attack. Suppose we have a training dataset on which we trained an NLP model. Then, we can augment the training dataset and generate prediction from our model on augmented texts. If the predictions are different than our ground-truth labels, then we have a list of texts where our model fails. We can get good insights by analyzing those responses.

Conclusion

Thus, MarianMT is a decent free and offline alternative to Google Translate for back-translation.

References

MarianMT - transformers 3.0.2 documentation

Connect

If you enjoyed the blog post, feel free to connect with me on Twitter where I share new blog posts every week.

Learning Plan to become a Machine Learning Engineer

Amit Chaudhary — Sun, 30 Aug 2020 09:42:12 +0000

Last year, in June 2019, I switched from a full-time web development role to a Machine Learning Engineer role.

To achieve that, I got help from many courses, articles, and books. I have documented all my learning resources below along with the goals:

https://github.com/amitness/learning

Django ORM if you already know SQL

Amit Chaudhary — Thu, 27 Aug 2020 06:26:08 +0000

If you are migrating to Django from another MVC framework, chances are you already know SQL.

In this post, I will be illustrating how to use Django ORM by drawing analogies to equivalent SQL statements. Connecting a new topic to your existing knowledge will help you learn to use the ORM faster.

Let us consider a simple base model for a person with attributes name, age, and gender.

To implement the above entity, we would model it as a table in SQL.

CREATE TABLE Person (
    id int,
    name varchar(50),
    age int NOT NULL,
    gender varchar(10),
);

The same table is modeled in Django as a class which inherits from the base Model class. The ORM creates the equivalent table under the hood.

class Person(models.Model):
    name = models.CharField(max_length=50, blank=True)
    age = models.IntegerField()
    gender = models.CharField(max_length=10, blank=True)

The most used data types are:

SQL	Django
`INT`	`IntegerField()`
`VARCHAR(n)`	`CharField(max_length=n)`
`TEXT`	`TextField()`
`FLOAT(n)`	`FloatField()`
`DATE`	`DateField()`
`TIME`	`TimeField()`
`DATETIME`	`DateTimeField()`

The various queries we can use are:

SELECT Statement

Fetch all rows

SQL:

SELECT *
FROM Person;

Django:

persons = Person.objects.all()
for person in persons:
    print(person.name)
    print(person.gender)
    print(person.age)

Fetch specific columns

SQL:

SELECT name, age
FROM Person;

Django:

Person.objects.only('name', 'age')

Fetch distinct rows

SQL:

SELECT DISTINCT name, age
FROM Person;

Django:

Person.objects.values('name', 'age').distinct()

Fetch specific number of rows

SQL:

SELECT *
FROM Person
LIMIT 10;

Django:

Person.objects.all()[:10]

LIMIT AND OFFSET keywords

SQL:

SELECT *
FROM Person
OFFSET 5
LIMIT 5;

Django:

Person.objects.all()[5:10]

WHERE Clause

Filter by single column

SQL:

SELECT *
FROM Person
WHERE id = 1;

Django:

Person.objects.filter(id=1)

Filter by comparison operators

SQL:

WHERE age > 18;
WHERE age >= 18;
WHERE age < 18;
WHERE age <= 18;
WHERE age != 18;

Django:

Person.objects.filter(age__gt=18)
Person.objects.filter(age__gte=18)
Person.objects.filter(age__lt=18)
Person.objects.filter(age__lte=18)
Person.objects.exclude(age=18)

BETWEEN Clause

SQL:

SELECT *
FROM Person 
WHERE age BETWEEN 10 AND 20;

Django:

Person.objects.filter(age__range=(10, 20))

LIKE operator

SQL:

WHERE name like '%A%';
WHERE name like binary '%A%';
WHERE name like 'A%';
WHERE name like binary 'A%';
WHERE name like '%A';
WHERE name like binary '%A';

Django:

Person.objects.filter(name__icontains='A')
Person.objects.filter(name__contains='A')
Person.objects.filter(name__istartswith='A')
Person.objects.filter(name__startswith='A')
Person.objects.filter(name__iendswith='A')
Person.objects.filter(name__endswith='A')

IN operator

SQL:

WHERE id in (1, 2);

Django:

Person.objects.filter(id__in=[1, 2])

AND, OR and NOT Operators

SQL:

WHERE gender='male' AND age > 25;

Django:

Person.objects.filter(gender='male', age__gt=25)

SQL:

WHERE gender='male' OR age > 25;

Django:

from django.db.models import Q
Person.objects.filter(Q(gender='male') | Q(age__gt=25))

SQL:

WHERE NOT gender='male';

Django:

Person.objects.exclude(gender='male')

NULL Values

SQL:

WHERE age is NULL;
WHERE age is NOT NULL;

Django:

Person.objects.filter(age__isnull=True)
Person.objects.filter(age__isnull=False)

# Alternate approach
Person.objects.filter(age=None)
Person.objects.exclude(age=None)

ORDER BY Keyword

Ascending Order

SQL:

SELECT *
FROM Person
order by age;

Django:

Person.objects.order_by('age')

Descending Order

SQL:

SELECT *
FROM Person
ORDER BY age DESC;

Django:

Person.objects.order_by('-age')

INSERT INTO Statement

SQL:

INSERT INTO Person
VALUES ('Jack', '23', 'male');

Django:

Person.objects.create(name='jack', age=23, gender='male)

UPDATE Statement

Update single row

SQL:

UPDATE Person
SET age = 20
WHERE id = 1;

Django:

person = Person.objects.get(id=1)
person.age = 20
person.save()

Update multiple rows

SQL:

UPDATE Person
SET age = age * 1.5;

Django:

from django.db.models import F

Person.objects.update(age=F('age')*1.5)

DELETE Statement

Delete all rows

SQL:

DELETE FROM Person;

Django:

Person.objects.all().delete()

Delete specific rows

SQL:

DELETE FROM Person
WHERE age < 10;

Django:

Person.objects.filter(age__lt=10).delete()

Aggregation

MIN Function

SQL:

SELECT MIN(age)
FROM Person;

Django:

>>> from django.db.models import Min
>>> Person.objects.all().aggregate(Min('age'))
{'age__min': 0}

MAX Function

SQL:

SELECT MAX(age)
FROM Person;

Django:

>>> from django.db.models import Max
>>> Person.objects.all().aggregate(Max('age'))
{'age__max': 100}

AVG Function

SQL:

SELECT AVG(age)
FROM Person;

Django:

>>> from django.db.models import Avg
>>> Person.objects.all().aggregate(Avg('age'))
{'age__avg': 50}

SUM Function

SQL:

SELECT SUM(age)
FROM Person;

Django:

>>> from django.db.models import Sum
>>> Person.objects.all().aggregate(Sum('age'))
{'age__sum': 5050}

COUNT Function

SQL:

SELECT COUNT(*)
FROM Person;

Django:

Person.objects.count()

GROUP BY Statement

Count of Person by gender

SQL:

SELECT gender, COUNT(*) as count
FROM Person
GROUP BY gender;

Django:

Person.objects.values('gender').annotate(count=Count('gender'))

HAVING Clause

Count of Person by gender if number of person is greater than 1

SQL:

SELECT gender, COUNT('gender') as count
FROM Person
GROUP BY gender
HAVING count > 1;

Django:

Person.objects.annotate(count=Count('gender'))
.values('gender', 'count')
.filter(count__gt=1)

JOINS

Consider a foreign key relationship between books and publisher.

class Publisher(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)

Fetch publisher name for a book

SQL:

SELECT name
FROM Book
LEFT JOIN Publisher
ON Book.publisher_id = Publisher.id
WHERE Book.id=1;

Django:

book = Book.objects.select_related('publisher').get(id=1)
book.publisher.name

Fetch books which have specific publisher

SQL:

SELECT *
FROM Book
WHERE Book.publisher_id = 1;

Django:

publisher = Publisher.objects.prefetch_related('book_set').get(id=1)
books = publisher.book_set.all()

Connect

If you enjoyed this blog post, feel free to connect with me on Twitter where I share new blog posts every week.

How to Automate Manual Steps after SSH

Amit Chaudhary — Thu, 27 Aug 2020 06:13:41 +0000

I recently worked on a Django web application which was deployed on a Linux Server with SSH access. Deployments
were done manually and the CI/CD pipeline was still in planning.

We had to perform these tasks every time to deploy the latest changes.

SSH into the server
Goto directory where the code is present
Activate Virtual Environment
Pull the latest changes on the current branch using Git
Install any newly added libraries from requirements.txt
Run migrations for the database
Run command to generate static files
Restart Nginx and Supervisor

I found the process repetitive and researched on whether it was possible to automate the commands I need to run
after SSHing into the server.

ssh -i "webapp.pem" ubuntu@example.com

Turns out, we can write a shell script to automate the task.

Step 1:

Create a new shell script file deploy.sh with the following content. Modify it to point to your PEM file, username, and IP address.

#!/bin/bash
ssh -i "webapp.pem" ubuntu@example.com << EOF
    echo "Hello World"
EOF

The above code prints 'Hello World' on the remote server.

Step 2:

You can write any shell commands between the two EOF and it will be run on the remote server.
Add the sequence of commands you currently run manually on the server to this script.

For the Django project, I wrote the following commands that pulls the latest code and restarts the services.

#!/bin/bash
ssh -i "webapp.pem" ubuntu@example.com << EOF
cd /var/www/webapp/

echo "Switching to www-data user"
sudo -Hu www-data bash

echo "Pulling Latest Changes"
git pull

echo "Activating Virtual Environment"
source venv/bin/activate

echo "Installing any new libraries"
pip install -r requirements.txt

echo "Migrating Database"
python manage.py migrate

echo "Returning back to Ubuntu user"
exit

echo "Restarting Supervisor and Nginx"
sudo service supervisor restart
sudo service nginx restart

echo "Deployment Finished"
EOF

Step 3:

Run the below command to change permissions of the script and make it executable.

chmod a+x deploy.sh

Step 4:

Run the script and it will perform all the deployment.

./deploy.sh

This simple script has saved me a lot of time until the CI/CD process is in place.

Connect

If you enjoyed this blog post, feel free to connect with me on Twitter where I share new blog posts every week.

Identify the Language of Text using Python

Amit Chaudhary — Thu, 27 Aug 2020 06:09:25 +0000

Text Language Identification is the process of predicting the language of a given a piece of text. You might have encountered it when Chrome shows a popup to translate a webpage when it detects that the content is not in English. Behind the scenes, Chrome is using a model to predict the language of text used on a webpage.

When working with a dataset for NLP, the corpus may contain a mixed set of languages. Here, language identification can be useful to either filter out a few languages or to translate the corpus to a single language and then use for your downstream tasks.

In this post, I will explain the working mechanism and usage of the fasttext language detection library.

Facebook's Fasttext library

Fasttext is an open-source library in Python for word embeddings and text classification. It is built for production use case rather than research and hence is optimized for performance and size. It extends the Word2Vec model with ideas such as using subword information and model compression.

For our purpose of language identification, we can use the pre-trained fasttext language identification models. The model was trained on a dataset drawn from Wikipedia, Tatoeba, and SETimes. The basic idea is to prepare a training data of (text, language) pairs and then train a classifier on it.

The benchmark below shows that these pre-trained language detection models are better than langid.py, another popular python language detection library. Fasttext has better accuracy and also the inference time is very fast. It supports a wide variety of languages including French, German, English, Spanish, Chinese.

Using Fasttext for Language Detection

Install the Fasttext library using pip.

pip install fasttext

There are two versions of the pre-trained models. Choose the model which fits your memory and space requirements:
- lid.176.bin: faster and slightly more accurate but 126MB in size
- lid.176.ftz: a compressed version of the model, with a file size of 917kB
Download the pre-trained model from Fasttext to some location. You'll need to specify this location later in the code. In our example, we download it to the /tmp directory.

wget -O /tmp/lid.176.bin https://dl.fbaipublicfiles.com/fasttext/supervised-models/lid.176.bin

Now, we import fasttext and then load the model from the pretrained path we downloaded earlier.

import fasttext

PRETRAINED_MODEL_PATH = '/tmp/lid.176.bin'
model = fasttext.load_model(PRETRAINED_MODEL_PATH)

Let's take an example sentence in French which means 'I eat food'. To detect language with fasttext, just pass a list of sentences to the predict function. The sentences should be in the UTF-8 format.

sentences = ['je mange de la nourriture']
predictions = model.predict(sentences)
print(predictions)

# ([['__label__fr']], array([[0.96568173]]))

The model returns back two tuples back. One of them is an array of language labels and the other is the confidence for each sentence. Here fr is the ISO 639 code for French. The model is 96.56% confident that the language is French.
Fasttext returns the ISO code for the most probable one among the 170 languages. You can refer to the page on ISO 639 codes to find language for each symbol.

af als am an ar arz as ast av az azb ba bar bcl be bg bh bn bo bpy br bs bxr ca cbk ce ceb ckb co cs cv cy da de diq dsb dty dv el eml en eo es et eu fa fi fr frr fy ga gd gl gn gom gu gv he hi hif hr hsb ht hu hy ia id ie ilo io is it ja jbo jv ka kk km kn ko krc ku kv kw ky la lb lez li lmo lo lrc lt lv mai mg mhr min mk ml mn mr mrj ms mt mwl my myv mzn nah nap nds ne new nl nn no oc or os pa pam pfl pl pms pnb ps pt qu rm ro ru rue sa sah sc scn sco sd sh si sk sl so sq sr su sv sw ta te tg th tk tl tr tt tyv ug uk ur uz vec vep vi vls vo wa war wuu xal xmf yi yo yue zh

To programmatically convert language symbols back to the language name, you can use pycountry package. Install the package using pip.

pip install pycountry

Now, pass the symbol to pycountry and you will get back the language name.

from pycountry import languages

lang_name = languages.get(alpha_2='fr').name
print(lang_name)
# french

Conclusion

Thus, we saw how fasttext can be used for language detection in Python. This is very useful to filter out and deal with non-english responses in Natural Language Processing projects.

Connect

If you enjoyed this blog post, feel free to connect with me on Twitter where I share new blog posts every week.

Migrating from OS.PATH to PATHLIB Module in Python

Amit Chaudhary — Thu, 27 Aug 2020 06:07:36 +0000

In this article, I will go over the most frequent tasks related to file paths and show how you can refactor the old approach of using os.path module to the new cleaner way using pathlib module.

Joining paths

import os
base_path = '/home/ubuntu/'
filename = 'data.csv'
os.path.join(base_path, filename)

In pathlib, we can use the division operator to separate the paths elegantly.

from pathlib import Path
base_path = '/home/ubuntu/'
filename = 'data.csv'
Path(base_path) / filename

Get absolute path

import os
os.path.abspath(__file__)

from pathlib import Path
Path(__file__).resolve()

Get current working directory

import os
os.getcwd()

from pathlib import Path
Path.cwd()

Check if path is a file

import os
os.path.isfile('/home/ubuntu/data.csv')

from pathlib import Path
Path('/home/ubuntu/data.csv').is_file()

Check if path is a directory

import os
os.path.isdir('/home/ubuntu/')

from pathlib import Path
Path('/home/ubuntu/').is_dir()

Check if a path exists

import os
os.path.exists('/home/ubuntu/')

from pathlib import Path
Path('/home/ubuntu/').exists()

Get path to folder containing a file

import os
os.path.dirname('/home/ubuntu/data.csv')
# /home/ubuntu

from pathlib import Path
Path('/home/ubuntu/data.csv').parent
# /home/ubuntu

Get the path to the home directory

import os
os.path.expanduser('~')

from pathlib import Path
Path.home()

Expand the user home directory in a path

import os
os.path.expanduser('~/Desktop')
# '/home/ubuntu/Desktop'

from pathlib import Path
Path('~/Desktop').expanduser()

Get size in bytes of a file

import os
os.path.getsize('/home/ubuntu/data.csv')

from pathlib import Path
Path('/home/ubuntu/data.csv').stat().st_size

Get file extension

import os
path, ext = os.path.splitext('/home/ubuntu/hello.py')
# ('/home/ubuntu/hello', '.py')

from pathlib import Path
Path('/home/ubuntu/hello.py').suffix
# .py

Change permission of a file

import os
os.chmod('key.pem', 0o400)

from pathlib import Path
Path('key.pem').chmod(0o400)

Get file name without directory

import os
os.path.basename('/home/ubuntu/hello.py')
# hello.py

from pathlib import Path
Path('/home/ubuntu/hello.py').name
# hello.py

List contents of a directory

import os
os.listdir()

from pathlib import Path
Path().iterdir()

Create a directory

import os
os.makedirs('/home/ubuntu/data', exist_ok=True)

from pathlib import Path
Path('/home/ubuntu/data').mkdir(exist_ok=True)

Rename files or directories

import os
os.rename('rows.csv', 'data.csv')

from pathlib import Path
Path('rows.csv').rename('data.csv')

Delete a directory

import os
os.rmdir('/home/ubuntu/test')

from pathlib import Path
Path('/home/ubuntu/test').rmdir()

Reading a file

import os
p = os.path.join('/home/ubuntu', 'data.csv')

with open(p) as fp:
    data = fp.read()

In new versions of python, you can directly pass a pathlib Path to the open() function.

from pathlib import Path
path = Path('/home/ubuntu/') / 'data.csv'

with open(path) as fp:
    data = fp.read()

In older versions, you can either convert the path to a string using str() or use the open() method.

from pathlib import Path
path = Path('/home/ubuntu/data.csv')

# Method: 1
data = path.open().read()

# Method 2
with open(str(path)) as fp:
    data = fp.read()

# Method 3
data = path.read_text()

Connect

If you enjoyed this blog post, feel free to connect with me on Twitter where I share new blog posts every week.

Transfer Learning in NLP with Tensorflow Hub and Keras

Amit Chaudhary — Thu, 27 Aug 2020 06:02:48 +0000

Tensorflow 2.0 introduced Keras as the default high-level API to build models. Combined with pretrained models from Tensorflow Hub, it provides a dead-simple way for transfer learning in NLP to create good models out of the box.

To illustrate the process, let's take an example of classifying if the title of an article is clickbait or not.

Data Preparation

We will use the dataset from the paper 'Stop Clickbait: Detecting and Preventing Clickbaits in Online News Media' available here.

Since the goal of this article is to illustrate transfer learning, we will directly load an already pre-processed dataset into a pandas dataframe.

import pandas as pd
df = pd.read_csv('http://bit.ly/clickbait-data')

The dataset consists of page titles and labels. The label is 1 if the title is clickbait.

Let's split the data into 70% training data and 30% validation data.

from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(df['title'], 
                                                    df['label'], 
                                                    test_size=0.3, 
                                                    stratify=df['label'], 
                                                    random_state=42)

Model Architecture

Now, we install tensorflow and tensorflow-hub using pip.

pip install tensorflow-hub
pip install tensorflow==2.1.0

To use text data as features for models, we need to convert it into a numeric form. Tensorflow Hub provides various modules for converting the sentences into embeddings such as BERT, NNLM and Wikiwords.

Universal Sentence Encoder is one of the popular module for generating sentence embeddings. It gives back a 512 fixed-size vector for the text.
Below is an example of how we can use tensorflow hub to capture embeddings for the sentence "Hello World".

import tensorflow_hub as hub

encoder = hub.load('https://tfhub.dev/google/universal-sentence-encoder/4')
encoder(['Hello World'])

In Tensorflow 2.0, using these embeddings in our models is a piece of cake thanks to the new hub.KerasLayer module. Let's design a tf.keras model for the binary classification task of clickbait detection.

First import the required libraries.

import tensorflow as tf
import tensorflow_hub as hub

Then, we create a sequential model that will encapsulate our layers.

model = tf.keras.models.Sequential()

The first layer will be a hub.KerasLayer from where we can loading models available at tfhub.dev. We will be loading Universal Sentence Encoder.

model.add(hub.KerasLayer('https://tfhub.dev/google/universal-sentence-encoder/4', 
                        input_shape=[], 
                        dtype=tf.string, 
                        trainable=True))

Here are what the different parameters used mean:

/4: It denotes the variant of Universal Sentence Encoder on hub. We're using the Deep Averaging Network (DAN) variant. We also have Transformer architecture and other variants.
input_shape=[]: Since our data has no features but the text itself, so there feature dimension is empty.
dtype=tf.string: Since we'll be passing raw text itself to the model
trainable=True: Denotes whether we want to finetune USE or not. We set it to True, the embeddings present in USE are finetuned based on our downstream task.

Next, we add a Dense layer with single node to output probability of clickbait between 0 and 1.

model.add(tf.keras.layers.Dense(1, activation='sigmoid'))

In summary, we have a model that takes text data, projects it into 512-dimension embedding and passed that through a feedforward neural network with sigmoid activation to give a clickbait probability.

Alternatively, we can implement the exact above architecture using the tf.keras functional API as well.

x = tf.keras.layers.Input(shape=[], dtype=tf.string)
y = hub.KerasLayer('https://tfhub.dev/google/universal-sentence-encoder/4', 
                    trainable=True)(x)
z = tf.keras.layers.Dense(1, activation='sigmoid')(y)
model = tf.keras.models.Model(x, z)

The output of the model summary is

model.summary()

The number of trainable parameters is 256,798,337 because we're finetuning Universal Sentence Encoder.

Training the model

Since we're performing a binary classification task, we use a binary cross entropy loss along with ADAM optimizer and accuracy as the metric.

model.compile(optimizer='adam', 
              loss='binary_crossentropy', 
              metrics=['accuracy'])

Now, let's train the model for

model.fit(x_train, 
          y_train, 
          epochs=2, 
          validation_data=(x_test, y_test))

We reach a training accuracy of 99.62% and validation accuracy of 98.46% with only 2 epochs.

Inference

Let's test the model on a few examples.

# Clickbait
>> model.predict(["21 Pictures That Will Make You Feel Like You're 99 Years Old"])
array([[0.9997924]], dtype=float32)

# Not Clickbait
>> model.predict(['Google announces TensorFlow 2.0'])
array([[0.00022611]], dtype=float32)

Conclusion

Thus, with a combination of Tensorflow Hub and tf.keras, we can leverage transfer learning easily and build high-performance models for any of our downstream tasks.

Data Credits

Abhijnan Chakraborty, Bhargavi Paranjape, Sourya Kakarla, and Niloy Ganguly. "Stop Clickbait: Detecting and Preventing Clickbaits in Online News Media”. In Proceedings of the 2016 IEEE/ACM International Conference on Advances in Social Networks Analysis and Mining (ASONAM), San Fransisco, US, August 2016

Connect

If you enjoyed this blog post, feel free to connect with me on Twitter where I share new blog posts every week.

Back Translation for Text Augmentation with Google Sheets

Amit Chaudhary — Thu, 27 Aug 2020 06:00:02 +0000

When working on Natural Language Processing applications such as Text Classification, collecting enough labeled examples for each category manually can be difficult. In this article, I will go over an interesting technique to augment your existing text data automatically called back translation.

Introduction to Back Translation

The key idea of back translation is very simple. We create augmented version of a sentence using the following steps:

You take the original text written in English
You convert it into another language (say French) using Google Translate
You convert the translated text back into English using Google Translate
Keep the augmented text if the original text and the back-translated text are different.

Figure: Back Translation
{: .text-center}

Using Back Translation in Google Sheets

We need a machine translation service to perform the translation to a different language and back to English. Google Translate is the most popular service for this purpose, but you need to get an API key to use it and it is a paid service.

Luckily, Google provides a handy feature in their Google Sheets web app, which we can leverage for our purpose.

Step 1: Load your data

Let's assume we are building a sentiment analysis model and our dataset has sentences and their associated labels. We can load it into Google Sheets by importing the Excel/CSV file directly.

Step 2: Add a column to hold augmented data

Add a new column and use the GOOGLETRANSLATE() function to translate from English to French and back to English.

The command to place in the column is

=GOOGLETRANSLATE(GOOGLETRANSLATE(A2, "en", "fr"), "fr", "en")

Once the command is placed, press Enter and you will see the translation.

Now, select the first cell of "Backtranslated" column and drag the small square at the bottom right side below to apply this formula over the whole column

This should apply to all your training texts and you will get back the augmented version.

Step 3: Filter out duplicated data

For texts where the original text and what get back from back translation are the same, we can filter them out programmatically by comparing the original text column and the augmented column. Then, only keep responses that have True value in the Changed column.

Step 4: Export your data

You can download your data as a CSV file and augment your existing training data.

Example Sheet

Here is a Google Sheet demonstrating all the four steps above. You can refer to that and make a copy of it to test things out.

Conclusion

Back translation offers an interesting approach when you've small training data but want to improve the performance of your model.

Connect

If you enjoyed this blog post, feel free to connect with me on Twitter where I share new blog posts every week.

The Python Magic Behind PyTorch

Amit Chaudhary — Thu, 27 Aug 2020 05:54:02 +0000

PyTorch has emerged as one of the go-to deep learning frameworks in recent years. This popularity can be attributed to its easy to use API and it being more "pythonic".

PyTorch leverages numerous native features of Python to give us a consistent and clean API. In this article, I will explain those native features in detail. Learning these will help you better understand why you do things a certain way in PyTorch and make better use of what it has to offer.

Magic Methods in Layers

Layers such as


 are some of the basic constructs in PyTorch that we use to build our models. You import the layer and apply them to tensors.



```python
import torch
import torch.nn as nn

x = torch.rand(1, 784)
layer = nn.Linear(784, 10)
output = layer(x)

Here we are able to call layer on some tensor x, so it must be a function right? Is nn.Linear() returning a function? Let's verify it by checking the type.

>>> type(layer)
<class 'torch.nn.modules.linear.Linear'>

Surprise! nn.Linear is actually a class and layer an object of that class.

"What! How could we call it then? Aren't only functions supposed to be callable?"

Nope, we can create callable objects as well. Python provides a native way to make objects created from classes callable by using magic functions.
Let's see a simple example of a class that doubles a number.

class Double(object):
    def __call__(self, x):
        return 2*x

Here we add a magic method __call__ in the class to double any number passed to it. Now, you can create an object out of this class and call it on some number.

>>> d = Double()
>>> d(2)
4

Alternatively, the above code can be combined in the single line itself.

>>> Double()(2)
4

This works because everything in Python is an object. See an example of a function below that doubles a number.

def double(x):
    return 2*x

>>> double(2)
4

Even functions invoke the__call__ method behind the scenes.

>>> double.__call__(2)
4

Magic methods in Forward Pass

Let's see an example of a model that applies a single fully connected layer to MNIST images to get 10 outputs.

import torch.nn as nn

class Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(784, 10)        

    def forward(self, x):
        return self.fc1(x)

The following code should be familiar to you. We are computing output of this model on some tensor x.

x = torch.rand(10, 784)
model = Model()
output = model(x)

We know calling the model directly on some tensor executes the .forward() function on it. How does that work?

It's the same reason in previous example. We're inheriting the class nn.Module. Internally, nn.Module has a __call__() magic method that calls the .forward(). So, when we override .forward() method later, it's executed.

# nn.Module
class Module(object):
    def __call__(self, x):
        # Simplified
        # Actual implementation has validation and gradient tracking.
        return self.forward(x)

Thus, we were able to call the model directly on tensors.

output = model(x)
# model.__call__(x) 
#   -> model.forward(x)

Magic methods in Dataset

In PyTorch, it is common to create a custom class inheriting from the Dataset class to prepare our training and test datasets. Have you ever wondered why we define methods with obscure names like __len__ and __getitem__ in it?

from torch.utils.data import Dataset

class Numbers(Dataset):
    def __init__(self, x, y):
        self.data = x
        self.labels = y

    def __len__(self):
        return len(self.data)

    def __getitem__(self, i):
        return (self.data[i], self.labels[i])

>>> dataset = Numbers([1, 2, 3], [0, 1, 0])
>>> print(len(dataset))
3
>>> print(dataset[0])
(1, 0)

These methods are builtin magic methods of Python. You know how we can get the length of iterables like list and tuples using len function.

>>> x = [10, 20, 30]
>>> len(x)
3

Python allows defining a __len__ on our custom class so that len() works on it. For example,

class Data(object):
    def __len__(self):
        return 10

>>> d = Data()
>>> len(d)
10

Similarly, you know how we can access elements of list and tuples using index notation.

>>> x = [10, 20, 30]
>>> x[0]
10

Python allows a __getitem__ magic method to allow such functionality for custom classes. For example,

class Data(object):
    def __init__(self):
        self.x = [10, 20, 30]

    def __getitem__(self, i):
        return x[i]

>>> d = Data()
>>> d[0]
10

With the above concept, now you can easily understand the builtin dataset like MNIST and what you can do with them.

from torchvision.datasets import MNIST

>>> trainset = MNIST(root='mnist', download=True, train=True)
>>> print(len(trainset))
60000
>>> print(trainset[0])
(<PIL.Image.Image image mode=L size=28x28 at 0x7F06DC654128>, 0)

Magic methods in DataLoader

Let's create a dataloader for a training dataset of MNIST digits.

from torchvision.datasets import MNIST
from torch.utils.data import DataLoader
import torchvision.transforms as transforms

trainset = MNIST(root='mnist', 
                 download=True, 
                 train=True, 
                 transform=transforms.ToTensor())
trainloader = DataLoader(trainset, batch_size=32, shuffle=True)

Now, let's try accessing first batch from the data loader directly without looping. If we try to access it via index, we get an exception.

>>> trainloader[0]
TypeError: 'DataLoader' object does not support indexing

You might have been used to doing it in this way.

images, labels =  next(iter(trainloader))

Have you ever wondered why do we wrap trainloader by iter() and then call next()? Let's demystify this.

Consider a list x with 3 elements. In Python, we can create an iterator out of x using the iter function.

x = [1, 2, 3]
y = iter(x)

Iterators are used because they allow lazy loading such that only one element is loaded in memory at a time.

>>> next(x)
1
>>> next(x)
2
>>> next(x)
3
>>> next(x)
StopIteration:

We get each element and when we reach the end of the list, we get a StopIteration exception.

This pattern matches our usual machine learning workflow where we take small batches of data at a time in memory and do the forward and backward pass. So, DataLoader also incorporates this pattern in PyTorch.

To create iterators out of classes in Python, we need to define magic methods __iter__ and __next__

class ExampleLoader(object):
    def __init__(self, data):
        self.data = iter(data)

    def __iter__(self):
        return self

    def __next__(self):
        return next(self.data)        

>>> l = ExampleLoader([1, 2, 3])
>>> next(iter(l))
1

Here, the iter() function calls the __iter__ magic method of the class returning that same object. Then, the next() function calls the __next__ magic method of the class to return next element present in our data.

In PyTorch, the implementation of DataLoader implements this pattern as follows:

class DataLoader(object):
    def __iter__(self):
        if self.num_workers == 0:
            return _SingleProcessDataLoaderIter(self)
        else:
            return _MultiProcessingDataLoaderIter(self)

class _SingleProcessDataLoaderIter(_BaseDataLoaderIter):
    def __next__(self):
        # logic to return batch from whole data
        ...

So, they decouple the iterator creation part and the actual data loading part.

When you call iter() on the data loader, it checks if we are using single or multiple workers
Based on that, it returns another iterator class for either single or multiple worker

>>> type(iter(trainloader))
torch.utils.data.dataloader._SingleProcessDataLoaderIter

That iterator class has a __next__ method defined which returns the actual data of set batch_size when we call next() on it

images, labels =  next(iter(trainloader))

# equivalent to:
images, labels = trainloader.__iter__().__next__()

Thus, we get images and labels for a single batch.

Conclusion

Thus, we saw how PyTorch borrows several advanced concepts from native Python itself in its API design. I hope the article was helpful to demystify how these concepts work behind the scenes and will help you become a better PyTorch user.

Connect

If you enjoyed this blog post, feel free to connect with me on Twitter where I share new blog posts every week.

A Visual Guide to Recurrent Layers in Keras

Amit Chaudhary — Thu, 27 Aug 2020 05:45:44 +0000

Keras provides a powerful abstraction for recurrent layers such as RNN, GRU and LSTM for Natural Language Processing. When I first started learning about them from the documentation, I couldn't clearly understand how to prepare input data shape, how various attributes of the layers affect the outputs and how to compose these layers with the provided abstraction.

Having learned it through experimentation, I wanted to share my understanding of the API with visualizations so that it's helpful for anyone else having troubles.

Single Output

Let's take a simple example of encoding the meaning of a whole sentence using a RNN layer in Keras.

Credits: Marvel Studios
{: .text-center}

To use this sentence in a RNN, we need to first convert it into numeric form. We could either use one-hot encoding, pretrained word vectors or learn word embeddings from scratch. For simplicity, let's assume we used some word embedding to convert each word into 2 numbers.

Now, to pass these words into a RNN, we treat each word as time-step and the embedding as it's features. Let's build a RNN layer to pass these into

model = Sequential()
model.add(SimpleRNN(4, input_shape=(3, 2)))

As seen above, here is what the various parameters means and why they were set as such:

input_shape=(3, 2):
- We have 3 words: I, am, groot. So, number of time-steps is 3. The RNN block unfolds 3 times, and so we see 3 blocks in the figure.
- For each word, we pass the word embedding of size 2 to the network.
SimpleRNN(4, ...):
- This means we have 4 units in the hidden layer.
- So, in the figure, we see how a hidden state of size 4 is passed between the RNN blocks
- For the first block, since there is no previous output, so previous hidden state is set to [0, 0, 0, 0]

Thus for a whole sentence, we get a vector of size 4 as output from the RNN layer as shown in the figure. You can verify this by printing the shape of output from the layer.

import tensorflow as tf
from tensorflow.keras.layers import SimpleRNN

x = tf.random.normal((1, 3, 2))

layer = SimpleRNN(4, input_shape=(3, 2))
output = layer(x)

print(output.shape)
# (1, 4)

As seen, we create a random batch of input data with 1 sentence having 3 words and each word having an embedding of size 2. After passing through the LSTM layer, we get back representation of size 4 for that one sentence.

This can be combined with a Dense layer to build an architecture for something like sentiment analysis or text classification.

model = Sequential()
model.add(SimpleRNN(4, input_shape=(3, 2)))
model.add(Dense(1))

Multiple Output

Keras provides a return_sequences parameter to control output from the RNN cell. If we set it to True, what it means is that the output from each unfolded RNN cell is returned instead of only the last cell.

model = Sequential()
model.add(SimpleRNN(4, input_shape=(3, 2), 
                    return_sequences=True))

As seen above, we get an output vector of size 4 for each word in the sentence.

This can be verified by the below code where we send one sentence with 3 words and embedding of size 2 for each word. As seen, the layer gives us back 3 outputs with a vector of size 4 for each word.

import tensorflow as tf
from tensorflow.keras.layers import SimpleRNN

x = tf.random.normal((1, 3, 2))

layer = SimpleRNN(4, input_shape=(3, 2), return_sequences=True)
output = layer(x)

print(output.shape)
# (1, 3, 4)

TimeDistributed Layer

Suppose we want to recognize entities in a text. For example, in our text "I am Groot", we want to identify "Groot" as a name.

We have already seen how to get output for each word in the sentence in previous section. Now, we need some way to apply classification on the output vector from the RNN cell on each word. For simple cases such as text classification, you know how we use Dense() layer with softmax activation as the last layer.

Similar to that, we can apply Dense() layer on multiple outputs from the RNN layer through a wrapper layer called TimeDistributed(). It will apply the Dense layer on each output and give us class probability scores for the entities.

model = Sequential()
model.add(SimpleRNN(4, input_shape=(3, 2), 
                    return_sequences=True))
model.add(TimeDistributed(Dense(4, activation='softmax')))

As seen, we take a 3 word sentence and classify output of RNN for each word into 4 classes using Dense layer. These classes can be the entities like name, person, location etc.

Stacking Layers

We can also stack multiple recurrent layers one after another in Keras.

model = Sequential()
model.add(SimpleRNN(4, input_shape=(3, 2), return_sequences=True))
model.add(SimpleRNN(4))

We can understand the behavior of the code with the following figure:

Insight: Why do we usually set return_sequences to True for all layers except the final?

Since the second layer needs inputs from the first layer, we set return_sequence=True for the first SimpleRNN layer. For the second layer, we usually set it to False if we are going to just be doing text classification. If out task is NER prediction, we can set it to True in the final layer as well.

References

Recurrent Layers - Keras Documentation

Connect

If you enjoyed this blog post, feel free to connect with me on Twitter where I share new blog posts every week.

DEV Community: Amit Chaudhary

A Visual Guide to Regular Expression

Mental Model

Basic Building Blocks

a. Specific character

b. White space character

c. Special sequences

Pattern: \d

Pattern: \s

Pattern: \w

Pattern: .

Pattern: Negations

d. Character sets

e. Anchors

f. Escaping metacharacters

Repetition of basic blocks

a. Naive repetition

b. Quantifiers

i. Fixed repetition

ii. Flexible quantifiers

Usage in Python

Need for raw strings

Using re module

1. re.findall

2. re.match

3. re.search

References

Connect

VSCode on Google Colab

Steps

Tips

References

Connect

Text Data Augmentation with MarianMT

Back Translation

Augmentation Process

Chained Back Translation

Available Models

Alternative Applications

Conclusion

References

Connect

Learning Plan to become a Machine Learning Engineer

Django ORM if you already know SQL

SELECT Statement

WHERE Clause

AND, OR and NOT Operators

NULL Values

ORDER BY Keyword

INSERT INTO Statement

UPDATE Statement

DELETE Statement

Aggregation

GROUP BY Statement

HAVING Clause

JOINS

Connect

How to Automate Manual Steps after SSH

Step 1:

Step 2:

Step 3:

Step 4:

Connect

Identify the Language of Text using Python

Facebook's Fasttext library

Using Fasttext for Language Detection

Conclusion

Connect

Migrating from OS.PATH to PATHLIB Module in Python

Joining paths

Get absolute path

Get current working directory

Check if path is a file

Check if path is a directory

Check if a path exists

Get path to folder containing a file

Get the path to the home directory

Expand the user home directory in a path

Get size in bytes of a file

Get file extension

Pattern: `\d`