DEV Community: Gurkirat Singh

Introduction and History of Regular Expression

Gurkirat Singh — Tue, 01 Aug 2023 05:00:00 +0000

Hello World! Welcome to the "Regular Expressions" series, where we tackle the intimidating syntax that has spawned numerous memes among developers. Don't worry, though! As we move forward, I assure you that you'll gain the confidence to craft your own elegant regular expressions by the end of this journey.

This cover image is taken from Midjourney.ai Discord server.

In this series, I will utilise https://regex101.com to share patterns with you, avoiding the constraint of a specific programming language that could potentially create barriers for some learners.

Note $→\to$ If anywhere coding is required, I will be using C++.

What are Regular Expressions?

Regular expressions are a specific type of text pattern that are used while programming a logic.

I couldn't think of a single modern application that doesn't make use of it, either directly or indirectly. If you went to a website and entered any gibberish text in the email field, you would have received an invalid email format message.

This image is taken from here

Under the hood, your input text is being verified by the following regex pattern.

[a-z0-9.-]@[a-z0-9]{2,}\.[a-z]{2,}

You can see how this regex works here. This is a minimal version of matching simple email addresses. Please bear with me if this appears overwhelming. Such expressions can be created in less than 10 seconds.

Why this name after all?

The name "regular expression" originates from the mathematical concept of regular languages, which were first studied by mathematicians in the field of formal language theory. Regular expressions are a way to describe and match patterns in strings of characters, hence the name "regular" expressions.

Problem that Led Development of RegExp

It was created in the 1950s (far before most of us were born) to help with text processing tasks, such as searching and editing. Since then, regular expressions have become a standard feature of many programming languages.

In the early 1960s, Ken Thompson implemented regular expressions in the QED text editor. This was the first time that regular expressions were used in a practical application.

Why You Should Learn Regular Expressions?

Learning regular expressions offers numerous benefits in various fields such as

data analysis
software development
content management
scientific research

Their versatility allows you to define complex patterns for finding specific words or phrases, extracting data from structured text, and performing advanced search and replace operations.

Additionally, mastering regular expressions helps prevent costly mistakes by providing a precise and controlled approach to text processing. With a solid understanding of regular expressions, you can confidently handle challenging text manipulation tasks, ensuring accuracy, reliability, and improved productivity.

Since you're here, I'm assuming you're ready to understand and use those unwieldy strings of brackets and question marks in your code.

Flavours of RegExp

There is no established standard that specifies which text patterns are and are not regular expressions. There are numerous languages on the market whose creators have various ideas about how regular expressions should look. So we're now stuck with a whole spectrum of regular expression flavours (implementation of RegExp in the programming language).

But why reinvent the wheel? Instead, every modern regular expression engine may be traced back to the Perl programming language.

Regular expression flavours are commonly integrated into scripting languages, while other programming languages rely on dedicated libraries for regex support. JavaScript offers built-in support for regular expressions using the syntax /expr/ or the RegExp object. On the other hand, Python implements regular expressions through its standard library re.

References

Automata theory is the study of abstract machines and automata, as well as the computational problems that can be solved using them. It is a theory in theoretical computer science with close connections to mathematical logic. The word automata comes from the Greek word αὐτόματος, which means "self-acting, self-willed, self-moving". An automaton is an abstract self-propelled computing device which follows a predetermined sequence of operations automatically. An automaton with a finite number of states is called a finite automaton (FA) or finite-state machine (FSM). The figure on the right illustrates a finite-state machine, which is a well-known type of automaton. This automaton consists of states and transitions. As the automaton sees a symbol of input, it makes a transition to another state, according to its transition function, which takes the previous state and current input symbol as its arguments.

View on Wikipedia>

A regular expression, sometimes referred to as rational expression, is a sequence of characters that specifies a match pattern in text. Usually such patterns are used by string-searching algorithms for "find" or "find and replace" operations on strings, or for input validation. Regular expression techniques are developed in theoretical computer science and formal language theory.

View on Wikipedia>

In logic, mathematics, computer science, and linguistics, a formal language consists of words whose letters are taken from an alphabet and are well-formed according to a specific set of rules called a formal grammar.

View on Wikipedia>

Contact Me

Email: tbhaxor at proton dot me
LinkedIn: @tbhaxor
Twitter: @tbhaxor

How to Think Before Designing Algorithms

Gurkirat Singh — Sun, 19 Jun 2022 00:02:32 +0000

Hello everyone! I am back with a new post which most of the new students struggle while learning about algorithms in undergrad courses. In this post, I will discuss the step by step process on how the developers usually undergo while thinking of solution to the problem and then designing algorithms.

It's the computer scientists who propose and invent new algorithms with improved features (usually time complexity) from the previous ones. For example, just look at searching algorithms. At the end, new constraints or inputs are added to the algorithms. The developers then use this algorithms and fit into the problems to get the things done in less time.

Step 1: Defining Problem

The problem created while discussion with the client and project manager isn't particularly technical, and it needs to be translated into technical terms so that it can be understood by the developers. Nerds!

For example let's take a simple problem statements.

How many users are coming to the application in a day and going to the checkout page and how many are abandoning it. Consider the timeout to be 300 seconds?

This could be shortened to the following

Classify the checkout session as completed or abandoned if it is inactive for 300 seconds, and then group by this label starting from 00:00:00 UTC to 23:59:59 UTC every day.

Step 2: Organising the Steps to Solve

From the problem statements, now it's time to interpret the statement and create the steps involved in the checkout completion or abandonment.

Checkout session create
Get the status by differentiating the current time with create time
If the time difference is 300 seconds, then mark it abandoned

Step 3: Automate it via an Algorithm

Use any programming and database to find all the checkout sessions created whose create time is less than current time and greater then current time - 300 seconds.

I have used MongoDB to implement this logic. You can check it on the playground, shared link below. I would recommend you to tinker with it and learn how it is working.

mongoplayground.net

Note This is supposed to be run periodically, therefore we need a cron job like feature in the application which is supposed to be executed at end of the day, everyday (59 59 23 * * *)

Step 4: Test it and Fix it Iteratively

What if the customer finally completes the checkout after some time has passed and the cron job has not yet been run? In the current scenario, this session will also be marked as abandoned. False positive is the term for this type of error.

Let's come to the second error type: What if the checkout session is abandoned for greater than 300 secs. It should also be counted as the abandoned, but with current logic, it is counted as completed. False negative is the term for this type of error.

What is the fix?

If the checkout is completed, there must be an order id linked to it. Therefore, if the property exists in the document, then the checkout is completed, otherwise it was abandoned by the user.

mongoplayground.net

Step 5: Make Sure your Solution is Effective and Efficient

Create a reusable function and try the same algorithm on real data after you've gotten your algorithm to work on the dummy data. This will help you decide whether or not to include it in the code base.

function getCheckoutStatus(startDate, endDate) {
  return db.collection.aggregate([
    {
      $match: { // get all the 
        createdAt: {
          $gte: startDate,
          $lt: endDate,
        },
      },
    },
    {
      $addFields: { // set status to completed if orderId exists; otherwise, abandon.
        status: {
          $cond: ["$orderId", "completed", "abandoned"],
        },
      },
    },
    {
      $group: { // group and aggregate the count
        _id: "$status",
        count: {
          $sum: 1,
        },
      },
    },
  ]);
}

The SQL equivalent of this could be

SELECT COUNT(*) AS completed FROM table WHERE `orderId` IS NOT NULL;
SELECT COUNT(*) AS abandoned FROM table WHERE `orderId` IS NULL;

If you get an error in this step, it means you didn't understand the problem to begin with. Return to step 2 and repeat the process.

A Comprehensive Guide on File Handling in C++

Gurkirat Singh — Sat, 09 Apr 2022 07:51:26 +0000

Hello World! You have been working with data in the program and struggling with saving its states across multiple restarts. Yeah, I know that is temporary and will be gone as the program exists. In this post, I will teach you how you can use C++ file handling and save not only text data into it but also binary data like Class or Struct.

You can clone the repository for all the snippets and source code used in this tutorial https://github.com/tbhaxor/cpp-file-handling-tutorial.

Why do you need File Handling Anyway?
Getting Started with File Handling
- Text File vs Binary File
- What is EOF
Writing into the File
Reading from the File
- Reading until line end (EOL)
Check Whether the File is Open or Not
Closing file handle
Appending into the Existing File
Storing Class Object in the File
Using I/O Streams of the File
- Read/Write Cursors

Why do you need File Handling Anyway?

The program state gets vanished when it is exited or the functions go out of scope during execution. Sometimes it's required to have the states for future execution.

Take the example of a game, you don't play it continuously. Saving the same and loading it later is very basic. I had first seen this in the Project IGI game and then Age of Empires. Nowadays multiplayer games are getting popular and they use databases to store this information.

That's a great idea to use databases. So why not use the database, it can be shared easily. Let me tell you that there is no different magic going on there, DBMS uses files to store the data. So it boils down to file handling.

Getting Started with File Handling

There are and will be 2 types of operation in the file: Read file will allow you to retrieve the content and write file will allow you to put the content into the file using the current stream. A stream is basically a channel that carries your data from/to the file.

std::ifstream class is used to open the file in reading mode and std::ofstream is used to open the file in the write mode.

These classes provide different methods and properties as an abstraction to deal with files, or I would say even the large files.

Text File vs Binary File

There are two types of files: Human readable (or text) and human non-readable (binary).

It is easy to determine whether a file is a text or binary: If you open a file in a text editor (let's assume notepad or vscode), it will show all the characters and you can pronounce them. They might or might not make sense, but it's not required here. This file is a text file. If you are unable to pronounce any character, then that file is a binary file.

Note A binary file can contain a few readable characters as well, and that is ok.

Text File	Binary File

What is EOF

While seeing the file format and the number of total bytes, we can determine that there are $n$ bytes in the file that can be read, but how does an opened stream will know in general? EOF is also known as End-of-File in computing. It is a condition or a notification to the file reader that tells no more retrieve more information from the file and seems like it is ended.

When you try to read a file and it is failed, both failed and eof bits are set in the error flags. You can use .eof() method to get this information.

So when does this bit set? An EOF bit is set after the ifstream reader tried to read the contents from the file and fails while the stream is still good (there is no error while performing I/O operations). So at least in the case of an ifstream, it waits for the OS to tell it that there's no more data ^{read more}

This is not only used for files but also streams and sockets

Programmatically, it will look like the following

std::cout << ifile->bad() << " " << ifile->eof() << " " 
          << ifile->fail();

// 0 1 1

Writing into the File

Enough talking, let's start by writing a text content into the file using std::ofstream. Before all of that, you need to instantiate the ofstream and open the file:

std::ofstream *file = new std::ofstream();
file->open("file.txt", std::ios::out);

You can use std::ofstream file; // w/o pointer as well, but I prefer pointers.

The .open() function, as it says, open the file with name (first argument) and the mode (second argument).

I will discuss different modes with you as we proceed, std::ios::out mode is used to tell the function, that opens the file in write mode, overwrite the contents of it if it exists or create a new one.

Now it's time to write into the file stream using the left shift operator <<. This will format all your data into char* before writing.

(*file) << "Hello World" << std::endl;

Since we are using a pointer variable, therefore it is required to dereference the file handle to access the << operator from the std::ofstream object stored.

Reading from the File

Reading is pretty simple and uses std::ifstream and >> operator with std::ios::in mode.

std::ifstream *file = new std::ifstream();
file->open(argv[1], std::ios::in);

For reading files in text mode, there is only one option std::ios::in

std::string data;
(*file) >> data;
std::cout << data << std::endl; // Hello\n

Reading until line end (eol)

When you write a file with << it formats whitespaces and streams that to the file, but while reading the content, it will stop at either EOF or the first whitespace character hit.

EOL or End-of-line is defined by the character \n or \r\n and is considered as the whitespace. So if there are multiple lines, you can use the std::getline() function.

std::getline(*file, data);
std::cout << data << std::endl; // Hello World\n

Check Whether the File is Open or Not

Till now we are believing that the file exists and is ready for any I/O operation, but what if the condition is otherwise? What if it failed to open? Will it throw an error?

The answer to the question is, NO. It will not throw error but the RW will not work. You can use std::ifstream::is_open() or std::ofstream::is_open(). The functions returns boolean value, so if the file is actually opened successfully, it will return true.

if (file->is_open()) {
     // do the rest actions here
} else {
    std::cout << "Unable to open file\n";
}

Closing file handle

When you are done with the file operations, it is recommended to close the file handle which will dispose of the file stream after writing any pending sequence of characters and clearing the buffer for both input and output streams.

For this you can use std::ofstream::close() or std::ifstream::close.

file->close();

If the file is not successfully opened, the function will fail and set the failbit flag.

Appending into the Existing File

What if you want to append the data into the file without losing old content. In the ios::out, it overwrites the file and reading the content of files, appending in memory and then writing to a file doesn't seem to be a space and time-efficient solution.

There is another mode of opening the file that you can use in place of ios::out, which is append mode ios::app. This will allow you to write from the end of the file to the size of the data.

When you choose to open the file with append mode, the put cursor of the handle is set at the end of the file.

file->open(argv[1], std::ios::app);

Storing Class Object in the File

So far you have seen me dealing with the text file, but in the real world, there are more than binary files with the custom format, like Zip archives, PDF files and other document files.

To open the file in binary mode, you need to specify std::ios::binary mode in the open() method of std::ifstream or std::ofstream.

in_file->open("file.bin", std::ios::binary | std::ios::in);

out_file->open("file.bin", std::ios::binary | std::ios::out);

For reading and writing, you must use std::ifstream::read() and std::ofstream::write() because the binary file saves the raw bytes and does not perform any kind of formatting.

With this, you can now store the object of structs or classes directly into the file without serializing it into the textual format. It will be then automatically deserialized when the file is read.

Let's create a simple class called Student that will have name and age fields and a whoami() method to return a std::string object.

class Student {
  private:
    std::string name;
    unsigned short age;
  public:
    Student() {
      this->name = ""
      this->age = 0;
    }

    Student(const char * name, unsigned short age) {
      this->name = std::string(name);
      this->age = age;
    }

  std::string whoami() const {
    std::stringstream s;
    s << "I am " << this->name << " and " << this->age << " years old";
    return s.str();
  }

};

Student student("Gurkirat Singh", 20);

You can save this to a file using the following snippet by casing it to char* because of its definition in the stdc++. ^{read more}

out_file->write(reinterpret_cast<char*>&student, sizeof(student));

Once this is successfully saved into the file, you will verify that there are some weird characters present in the file and that is normal, because the string data also stores the information of deserializing the object.

Student mystudent;
in_file->read(reinterpret_cast<char*>&mystudent, sizeof(mystudent));

std::cout << mystudent.whoami() << std::endl; // I am Gurkirat Singh and 20 years old

Now as a beginner, you must be thinking that the Student type is different from the char type. So why does the casting pointer not affect serialization? I would like to tell you that, you are getting confused between pointer type and other data types. For any data type, the pointer type would be 8 bytes or 4 bytes based on the CPU architecture, because it stores the starting address of the memory where that actual data of a type is stored. If the type of data is char, then it will consume 1 byte in the memory otherwise sizeof(T).

Using I/O Streams of the File

It is not like you can open a file only in one mode (that is either read or write), using std::fstream you can perform both input/output operations on the file with the same file handle.

Read/Write Cursors

There are two types of cursors in the file get and put. The get cursor is responsible for handling reading from the file which is known as input operation and the put cursor is responsible for handling writing into the file which is known as output operation.

To get the current position of the cursors, use the std::fstream::tellp() or std::fstream::tellg(). You can also set the position of these cursors making (either forward or backward) while the file is open using std::fstream::seekp() or std::fstream::seekg() functions.

You can also seek the cursor relatively based on the three types of the seek directions

std::ios::beg — from the beginning of file
std::ios::cur — from the current position of the cursor
std::ios::end — from the ending of the file or where the reader hits EOF

Note You must clear the flags using std::fstream::clear() to clear all the error bits before using seekg() or seekp(). ^{read more}

Introduction to Linux for Developers

Gurkirat Singh — Thu, 24 Mar 2022 19:50:44 +0000

Hello friends! In this post, I will try to explain to you why I prefer Linux-based OS for development. Not only because it's free, but also you have full control over organising and customising the OS as per your requirements, no enforcement from the vendor's end. I will try to explain the working of Linux in brief and try to gain your trust in switching to any Linux-based OS.

If you are coming from Windows OS, in the starting, it would be hard for you to grasp the knowledge because till now in a closed source operating system everything is pre-built for you. All you need to do is give a certain partition configuration and install it.

Why Linux for Development?

I have seen many developers misunderstand Linux as an operating system and then get puzzled by different distros. Guys hold your pace! Linux is just a kernel, which means it's the core that allows bridging the gap between hardware and the software world. When you have a kernel with a bunch of software that is commonly used in our daily lives, we call it an Operating System.

Yes but, then why do you need external drivers for communicating new hardware devices? Well, long story short, new devices are coming into the market every day and it's kinda hard for Linux developers to maintain a repository for all of them. Kernel focuses on managing the crucial resources like CPU execution time, memory, disk, and networking in the OS.

Is it really a synonym of CLI?

Yeah when I was a beginner in OS and encountered my first ever SSH connection back in days while learning Linux in my college, I also made this perception that Linux is all about handling CLI like old school in DOS. Well, this is not true. In Linux, there are several third-party software you can install and start the GUI. It's the choice of the user whether to work like on a terminal or a GUI. In this section, I will guide you about different packages that build up the Graphical Interface on top of Linux Kernel.

On the ground level, it's a minimal server used for handling the communication between GUI elements like mouse and keyboard by defining a set of protocols for the same. One of the most common examples of this is the X11 server or the Way-land.

On the top of X Server, window managers are built to handle different windows to open the application. You see the close, minimise and maximise buttons and think how a window is created to show the content of a particular process in it, well which is all handled by these window managers. Apart from basic window management, they offer additional services out of the box like tabs, visual effects, and multiple desktops. An example of this could be KWin and Mutter.

You might have heard people often debating about KDE vs Gnome, etc. Well, those are examples of what we call Desktop Environments. They are built on top of window managers and managed by specific communities. It consists of all the magical things you see in the GUI, like different panels, widgets, drag-and-drop features of files and similar contents, the configuration of services via GUI-based inputs controls like switches and knobs.

These all 3 components – X Window System + Window Manager + Desktop Environment work in harmony to provide a full graphical experience in the Linux-based distros. The cool thing is you have full autonomy to decide which of these to use and with what type of customisation.

Reading Man Pages - User manual for Linux

In this journey, documentation is your best friend. You should be able to understand a lot of things from the documentation provided by the project maintainers to build, customize and troubleshoot them. In Linux, you can use man pages for that using man command.

These manual pages are used to get help regarding any command or library function shipped with the packages. See man man for more information. Sometimes it's hard to remember the function name or the exact thing to look but we have an idea of what we are looking for. So in that case you can use apropos the command followed by the text to find the topic and then later use the man page for it.

For example, I forgot a command to get the memory dump of the program. So in this case I can use the apropos ssh copy command and then it will search from the man page index locally and get the appropriate topic with a brief description about it to differentiate the usage among others.

$ apropos ssh cop
btrfs-select-super (8) - overwrite primary superblock with a backup copy
cp (1)               - copy files and directories
cpgr (8)             - copy with locking the given file to the password or group file
cpio (1)             - copy files to and from archives
cppw (8)             - copy with locking the given file to the password or group file
dd (1)               - convert and copy a file
debconf-copydb (1)   - copy a debconf database
git-checkout-index (1) - Copy files from the index to the working tree
git-shell (1)        - Restricted login shell for Git-only SSH access
hpcopy (1)           - copy files from an HFS+ volume
install (1)          - copy files and set attributes
mcopy (1)            - copy MSDOS files to/from Unix
ntfscp (8)           - copy file to an NTFS volume.
objcopy (1)          - copy and translate object files
rcp (1)              - OpenSSH secure file copy
scp (1)              - OpenSSH secure file copy
sg_copy_results (8)  - send SCSI RECEIVE COPY RESULTS command (XCOPY related)
sg_dd (8)            - copy data to and from files and devices, especially SCSI devices
sg_xcopy (8)         - copy data to and from files and devices using SCSI EXTENDED COPY (XCOPY)
sgm_dd (8)           - copy data to and from files and devices, especially SCSI devices
sgp_dd (8)           - copy data to and from files and devices, especially SCSI devicesy

I have trimmed a lot of output here, but you can add some strict constraints like only getting the entries if it has all the keywords otherwise ignore them. Well, you will have to add -a switch after the apropos command.

$ apropos -a ssh copy
rcp (1)              - OpenSSH secure file copy
scp (1)              - OpenSSH secure file copy
ssh-copy-id (1)      - use locally available keys to authorise logins on a remote machine

Types of Man Page Categories

As you can see there are different numbers assigned to similar or different entries in the index. What does that mean? Well, there are about 8 different categories of information in Linux and each command or same function are logically grouped into them. The following is copied from the man page of the man using man man.

The table below shows the section numbers of the manual followed by the types of pages they contain.


       1   Executable programs or shell commands
       2   System calls (functions provided by the kernel)
       3   Library calls (functions within program libraries)
       4   Special files (usually found in /dev)
       5   File formats and conventions, e.g. /etc/passwd
       6   Games
       7   Miscellaneous (including macro packages and conventions),
           e.g. man(7), groff(7)
       8   System administration commands (usually only for root)
       9   Kernel routines [Non standard]

Most of the time you will deal with 1, 2, 4, and 8 sections only. Others are helpful when you are into Linux system development.

You can get the information of different sections either from apropos search or "SEE ALSO" section on the man page of a specific entry. For example, while reading the man's man page, I found there is one more entry for the same man(7).

By default it will try to look into the very first category, you can provide additional argument before the name that specifies a particular category to look into. If the entry does not exist in the man database, it will return an error otherwise open the man page for you. For example, in this case, if you can open the 7th category man page of the man using man 7 man.

Authentication Best Practices in the Web Applications

Gurkirat Singh — Thu, 10 Mar 2022 05:00:55 +0000

Hello World! Web development is one of the most popular fields nowadays and we can see every day new developers are joining this field because of high-paying jobs. Javascript is the most common and loved language among developers because it offers a lot of frameworks available to make the development process look like a piece of cake and its ecosystem of course.

In my past working with different teams, I have realized that developers (sometimes including me, I am not the perfect guy) do not take the most crucial processes of authentication seriously and because of this, it leaves security vulnerabilities in the application.

What is Authentication Anyway?

Let's understand with a very obvious example what does authentication means in the web application. Suppose you are going to the nightclub to have a beer and the person in charge ask for your identity to confirm your age which is required to enter. Now if you have this and the age is above that of what the government has decided, you are "allowed" to enter the club and you will be stamped on your hand. Whenever you are supposed to "prove your identity" to another party, the process is known as authentication.

How does authentication differ from authorisation?

I see people often confused with authentication and authorisation. Well at some point I also got confused but later it seemed a thin line between these two. Let's take the same club example and explore this.

Suppose you are willing to go inside the club and explore its resources, but you forgot to carry the identity card. In that case, you have no right or access to its infrastructure. One can also say that "Hey you are not authorised to enter the club". Or even though you have passed the first process of authentication, but still there are some areas where only the staff of the club are allowed to enter (like the kitchen or behind the bartender table). So whenever "right to access" comes into the frame, you are talking about authorisation.

If we see from the top, the authentication is also a form of authorisation which will give you right to access the resources that you are initially not allowed to.

Understanding Cookies in Detail

The session is stored on the server-side and the public identity of the session is saved on the client side every time there is a successful call to the login route. The server instructs the client by sending the Set-Cookie header in the response with some extra data that instruct the browser on how to store this information.

Let's try sending an authentication request to a live server and see how it responds.

curl 'https://authenticationtest.com//login/?mode=simpleFormAuth' \
--data-raw 'email=simpleForm%40authenticationtest.com&password=pa%24%24w0rd' \
--compressed -i

Well as you can see in the response I have the cookie name PHPSESSID and its value 2ifo.....

Once this cookie is set successfully on the browser storage, it is automatically mapped with the current domain name (here authenticationtest.com). So whenever the request will be made to the resources on this domain, the browser will automatically include the cookie name and its value in the Cookie header which will be then used by these resources to identify the user.

Note: Cookies are also used by tracking services like google ads, Facebook pixel and etc. So when you enable anti-trackers on the browser, they simply disallow the browser setting these cookies.

Setting the Expiration Configuration

The Max-Age option in the Set-Cookie header tells the browser after how many seconds automatically expire this cookie and delete it from its storage. This is optional because there is also another option by setting the Expires option which accepts the UTC format of date and time exactly when to expire the cookies on the client-side.

When the Max-Age is zero or a negative number, it will expire the cookie immediately after storing and when the Expires option is present along with this, the Max-Age has more precedence.

Some of the examples of the Set-Cookie header with this configuration are shown below

Set-Cookie: MYCOOKIE=Hello World; Max-Age=60  // This will be expired after 1 minute
Set-Cookie: MYCOOKIE=Hello World; Max-Age=-1  // This will be expired immediately
Set-Cookie: MYCOOKIE=Hello World; Max-Age=0
Set-Cookie: MYCOOKIE=Hello World; Expires=Wed, 1 Mar 2023 00:00:00 UTC // This will be expired on 1st march 2023 UTC time
Set-Cookie: MYCOOKIE=Hello World; Max-Age=60; Expires=Mon, 26 Mar 2018 17:04:05 UTC   // The Max-Age configuration will use and the cookie will be expired in 1 minute

Sending the Cookie on a Specific Document Path

Suppose you have two cookies, one is supposed to send on all the requests and another is to be sent on a specific document. How would you control this since they are automatically sent by the browsers? This feature is implemented in the Path option of the Set-Cookie header.

When the path is only /, the cookie will be sent for all the requests, but when the valid path exists in the option, it will be only sent if the document location matches with the path in the form of "starts with" regex. Let me explain to you with an example – Suppose the path of the cookie is set to the /secret, then this cookie will be sent for all the resources starting with "/secret", including /secret/, /secret/doc, /secret/doc/ and so on.

Some of the examples are shown below

Set-Cookie: MYCOOKIE=Hello World; Path=/          // This will be sent on all the resource requests
Set-Cookie: MYCOOKIE=Hello World; Path=/secret    // This will be sent on all the resource requests whose document location starts with /secret

This option can be used to provide the special permissions (authorization) on the specific path to the specific users.

Sending the Cookies on Secure Connection

When the request is made over a secure connection such as an HTTPS connection whether the network packets are signed by a secure hashing function a certificate, it becomes hard for the attacker to perform a man-in-the-middle attack to read or tamper with the request.

Therefore to provide security from MITM attacks in the network, the server can instruct the browser to send the cookie only if the request is made in a secure environment under HTTPS. This can be done by providing Secure option in the Set-Cookie header as demonstrated below

Set-Cookie: MYCOOKIE=Hello World // This will be sent on requests made in both Http and Https connection
Set-Cookie: MYCOOKIE=Hello World; Secure // This will be sent only on requests made in Https connection

Allowing Only HTTP Requests to Read Cookies

If somehow the attackers get control to execute arbitrary javascript commands on the website, they can get the cookies using document.cookie and which contains your proof of identity of the website and use it to perform actions on your behalf.

Need not worry, the browser got you covered. You can set a HttpOnly flag in the Set-Cookie header of the authentication response which will indicate the browser to only use this cookie when performing HTTP requests. You can still see the cookies via the developer console window, but not via javascript.

Set-Cookie: MYCOOKIE=Hello World; // This can be accessed by document.cookie API
Set-Cookie: MYCOOKIE=Hello World; HttpOnly // This can only be accessed while making http connections
Set-Cookie: MYCOOKIE=Hello World; HttpOnly; Secure // This can only be accessed while making secure http (https) connections

Best practices for the developers

There are a few best practices that I use and recommend to you if you are new to the javascript world

The users do not log out of the application and the sessions are kept on the login state. Make sure that there should be an expiration for the cookies or tokens. This will prevent the infinite login time for the user reminding them to log in to the applications. I would recommend you having 7 - 14 days of expiration time
The users often rely on the external password manager like 1Password or browser built-in features. This helps them to use strong passwords without remembering all of them. The forms with proper names and inputs should be used so that password managers recognise them and automatically save and fill them. This will remove time to enter the password which can be seen by someone (kind of eavesdropping)
When the user clicks on the logout button, the backend request should be made to invalidate cookies, tokens. This is a step ahead of security measures for the first point. Just in the case through XSS the cookies are stolen, it should be invalidated in the backend (associated session) so that it now becomes useless for the attackers.
Even if you think the information is not as sensitive, always encrypt the cookies to a specific algorithm and same as decryption logic in the server. I would rather recommend you use a hashing algorithm and associate the user id with it on the sessions table. When the cookie is present in the protected resources, try to get the user from user id associated with that cookie hash.
Apply rate-limiting to the requests brute-forcing cookie header to avoid accidentally guessing the correct cookie for a user on your application.
Use of HttpOnly + Secure cookies are 10 times more secure than other cookies as it allows the browser to send the cookies only when the HTTP connection is made to that domain and document and secure will ensure that the protocol is secured by TLS so that there is no chance of MITM attack

References

Making Your Google Colab Notebook More Interactive

Gurkirat Singh — Thu, 15 Apr 2021 07:32:23 +0000

Hey, devs! Long time no post. I have been learning deep learning for so long time and using google colab for my projects. You know, free GPU 😅 and demos.

I also used colab to send the proof of concepts or MVP to the clients and every time the clients faced problems in interacting with the notebook.

This made me think every time can I make my notebook more interactive? Are there any pre-validations? What is the difference between Jupiter and google colab if it doesn't offer anything new but free GPU or TPU instances. Well, I kept on digging in and found that it does support interactive inputs of different types.

In colab, it's known as "Forms"

I won't make this boring by adding too much text, google team has already created an example notebook explaining everything which is possible with forms. You can find the link of it below ⇓

https://colab.research.google.com/notebooks/forms.ipynb

PyTorch :: Performing Derivatives on Tensors

Gurkirat Singh — Wed, 06 Jan 2021 17:28:57 +0000

Hello everyone,

Especially to those who fear from maths :P

In this you will learn how to perform derivatives on tensors using pytorch. Let me tell you, once you will learn, it will be fun for you.

Basically the derivatives are used for generating the parameters in the neural network. For now you will learn the basics of derivatives.

Suppose you have a function $f(x) = x^2$ , so according to calculus, the derivative of $f (x)$ would be $df(x)x=2x1\frac{d f(x)}{x} = 2x^1$

Let's see how can we do this and find the value of where $x=9$

import torch

x = torch.tensor(9.0, requires_grad=True)
print(x)

tensor(9., requires_grad=True)

This time I am setting requires_grad=True, this means we are using pytorch autograd engine to compute the derivatives. Derivatives are calculated by tracing the graph (enabled when requires_grad=True) from root to leaf by using chain rule (back propagation).

Note Only Tensors of floating point dtype can require gradients

For more information you can read this wonderful post: https://towardsdatascience.com/pytorch-autograd-understanding-the-heart-of-pytorchs-magic-2686cd94ec95

Also you can read the official documentation regarding autograd on pytorch's website: https://pytorch.org/docs/stable/notes/autograd.html

Moving on, let's calculate $x^2$

y = x**2
print(y)

tensor(81., grad_fn=<PowBackward0>)

If you would see, this time the pytorch has attached a gradient function with the tensor.

To calculate the derivative, you need to call Tensor.backward() method.

And use .grad property on the leaf tensor (here it's $x$)

y.backward()
print(x.grad)

tensor(18.)

Isn't it look like a magic to you? Let's calculate the derivative of another complex equation.

\sin ( \frac{x}{2 \sqrt 2} )

Where $x = 100$

If you would simplify the denominator $\sqrt 2$ , it would be $2322^{\frac{3}{2}}$

x = torch.tensor(100., requires_grad=True)

y = torch.sin(x / (2 ** 1.5) )

print(x)
print(y)

y.backward()
print(x.grad)

tensor(100., requires_grad=True)
tensor(-0.7158, grad_fn=<SinBackward>)
tensor(-0.2469)

If you want to test it, you can go to https://www.derivative-calculator.net/ and type in the above expression.

You can also calculate the partial derivatives in pytorch. For example you have $f(u,v) = uv + u^2 + v^3$ , the derivative $df(u,v)du=2u+v\frac{d f(u,v)}{du} = 2u + v$ and $df(u,v)dv=3v2+u\frac{d f(u,v)}{dv} = 3v^2 + u$

Let's calculate the partial derivative using pytorch where $u = 2, v = 4$

u = torch.tensor(2., requires_grad=True)
v = torch.tensor(4., requires_grad=True)

f = u**2 + v**3 + u*v

print(u)
print(v)
print(f)

f.backward()
print(u.grad)
print(v.grad)

tensor(2., requires_grad=True)
tensor(4., requires_grad=True)
tensor(76., grad_fn=<AddBackward0>)
tensor(8.)
tensor(50.)

If you have doubts or any idea reach me out via following sources

Email: tbhaxor@gmail.com (Recommended)
Twitter: @tbhaxor
GitHub: @tbhaxor
LinkedIn: @gurkirat--singh
Instagram: @_tbhaxor_

GCP Essentials :: Compute Engine

Gurkirat Singh — Sun, 03 Jan 2021 20:10:11 +0000

Hello everyone,

Among all of other services that I would be discussing in further posts, Virtual Machine may be the most familiar and common.

In this I will discuss about the Compute Engine service of Google Cloud Platform which is the service for spinning up a vps on GCP.

One of the nice things about virtual machines is that they have the power and generality of a full-fledged operating system. You can flexibly configure a VPS pretty much like you configure your PC, deciding CPU, memory (type and size) and storage (types and size).

You will also learn configuring the vpn and firewall to make your vps even more secure.

Ohk so if you coming from some other cloud service provider, let me amaze you with this: The VPC networks that you define have global scope. They can have subnets in any GCP region worldwide and subnets can span the zones that make up a region.

This feature let you create your own network configuration and use it as you wish.

Not only this but you can dynamically increase the size of a subnet in a custom network by expanding the range of IP addresses allocated to it. Doing that doesn't affect already configured VMs.

You can find the created instances here: https://console.cloud.google.com/compute/instances

in gcloud

gcloud compute instances list --project=<PROJECT-ID>

If you not created any instances, you will see the dashboard as above.

So while creating the instances, you will see the 4 types of instances.

General Purpose : Hosting static website or simple webapps
Compute Optimized : High quality dedicated CPUs
Memory Optimized : High quality dedicated RAM with more space
GPU : Add the Graphical Processing Units for deploying / training machine learning applications

I will be choosing General Purpose E2 Series and e2-medium machine for deployment.

Then in base image and disk space, I have chosen the following

NOTE: If you want you instance to access the google apis, select second or third option based on your architecture

Currently I will be using the default access.

Most of the time you will be deploying a web application on the server. If that is the case, check the firewall rules based on type of traffic you will be receiving

I will be selecting the HTTP rule for now.

Recheck everything and click "Create" button. Give some time to created and boot the instance.

To create the same instance via gcloud sdk execute the following command

gcloud beta compute --project=<PROJECT-ID> instances create myinstace --zone=europe-west2-c --machine-type=e2-medium --subnet=default --network-tier=PREMIUM --maintenance-policy=MIGRATE --service-account=<YOUR-SERVICE-ACCOUNT> --scopes=https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring.write,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/trace.append --tags=http-server --image=ubuntu-2004-focal-v20201211 --image-project=ubuntu-os-cloud --boot-disk-size=30GB --boot-disk-type=pd-standard --boot-disk-device-name=myinstace --no-shielded-secure-boot --shielded-vtpm --shielded-integrity-monitoring --reservation-affinity=any

and execute this command to add the HTTP rule for the instance

gcloud compute --project=<PROJECT-ID> firewall-rules create default-allow-http --direction=INGRESS --priority=1000 --network=default --action=ALLOW --rules=tcp:80 --source-ranges=0.0.0.0/0 --target-tags=http-server

Once it's created, you need the private key to access the VPC using ssh. The easiest way to connect to the server is gcloud. It will created the SSH keys automatically (if doesn't exists) and then create

gcloud beta compute ssh --zone <ZONE-ID> <INSTANCE-NAME> --project <PROJECT-ID>

You can also connect to the instance from browser console. Click on the VPC you want to connect then click "Open in Browser"

NOTE: The default username that is created while instance creation is ubuntu

Since you might be a windows user or if you are linux user, gcloud will create the current logged in user in your VPC. So I personally recommend you to use the in-browser console for accessing the VPC. It will create the same username from every system you will access it.

Resources

I am waiting to see what have you deployed on your compute engine and how you are using it. Hit me up at the following

Email: tbhaxor@gmail.com (Recommended)
Twitter: @tbhaxor
GitHub: @tbhaxor
LinkedIn: @gurkirat--singh
Instagram: @_tbhaxor_

PyTorch :: Understanding Tensors (Part 2)

Gurkirat Singh — Fri, 01 Jan 2021 15:46:19 +0000

Hello friends, Happy new year

So far you have understood the types and shapes of the tensors. In this I will go more beyond the basics and teach you some more concepts about the tensors.

I have created this as Part-2 as all the information in one post was lengthy :P

Table of Contents

Indexing and Slicing of Tensors
Arithmetic Operations on Tensors
Basic Functions on the Tensors
Operations on 2D Tensors

Indexing and Slicing of Tensors

The individual values of the tensors are also a tensor, for instance

import torch

t1 = torch.tensor([1, 2, 3, 4])
print(t1[0])

tensor(1)

Since the original tensor was of 1-D, the value would be of course a 0-D tensor. So to if you have 2-D tensor, and are doing using only one index, you will get 1-D tensor

import torch

t2 = torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]])
print(t2[0])

tensor([1, 2, 3, 4])

NOTE: If you want to get the raw python list of 1+ D tensors, you can use Tensor.tolist() method

Like normal list, you can also update the tensor value by simply accessing the index. For example

t1[2] = 100
print(t1)

tensor([1, 2, 100, 4])

NOTE For your sake, pytorch returns a new tensor object whenever you perform slicing on the original tensor. But it will overwrite the original tensor when you will change the value of tensor at particular index.

Arithmetic Operations on Tensors

The very basic operations on tensors are vector additions and subtractions. Visit the link in case you want to study the maths behind these vector operations

Suppose you have two tensors $u$ and $u$ defined as

u = torch.tensor([1.0, 2.0])
v = torch.tensor([3.0, 4.0])

print(u)
print(v)

tensor([1., 2.])
tensor([3., 4.])

Then the vector operations addition and subtraction respectively

print(u + v)
print(u - v)

tensor([4., 6.])
tensor([-2., -2.])

Scalar operations are also supported. For example, taking $5$ as our scalar quantity

ws = torch.tensor(5)
print(ws)

tensor(5)

The operations addition, subtraction, multiplication and division are shown respectively

print(u + v + ws)
print(u + v - ws)
print(u + v * ws)
print(u + (v / ws))

tensor([ 9., 11.])
tensor([-1.,  1.])
tensor([16., 22.])
tensor([1.6000, 2.8000])

In pytorch, there is no need of creating a 0D tensor to perform scalar operations you can simply use the scalar value and perform the action. For example,

print(v * 5)

tensor([15., 20.])

The cross-product is fairly short and easy, by using * symbol. But to perform dot product, you should use torch.dot(vector1, vector2) or Tensor.dot(vector2)

print(u * v)
print(torch.dot(u, v))
print(u.dot(v))

tensor([3., 8.])
tensor(11.)
tensor(11.)

NOTE While performing cross-product or dot-product, dimensions of both the tensors should be equal, otherwise you will get RuntimeError

Basic Functions on the Tensors

Torch tensors provide a plethora of functions that you can apply on the tensors for the desired results. The first one of all is Tensor.mean()

x = torch.tensor([1, 2, 3, 4, 5], dtype=torch.float32)
print(x)
print(x.mean())

tensor([1., 2., 3., 4., 5.])
x.mean()

NOTE Since mean of a tensor will be a floating tensor, you can find the mean of floating tensor only otherwise you will get RuntimeError

Finding maximum or minimum value in the tensor can be done by using Tensor.max() and Tensor.min() respectively

print(x.max())
print(x.min())

tensor(5.)
tensor(1.)

You can also apply a function to a tensor element-wise. Suppose you have tensor containing various values of pi and you want to apply the sin and cos function on it. You can use torch.sin(tensor) and torch.cos(tensor)

import numpy as np

x = torch.tensor([0, np.pi / 2, np.pi])
print(x)
print(torch.sin(x))
print(torch.cos(x))

tensor([0.0000, 1.5708, 3.1416])
tensor([ 0.0000e+00,  1.0000e+00, -8.7423e-08])
tensor([ 1.0000e+00, -4.3711e-08, -1.0000e+00])

Sometimes you will have to get an evenly spaced list of numbers between a range, you can use torch.linspace(start, end, [step])

Let's make it more interactive by plotting the $sin⁡(−π)\sin (- \pi )$ to $sin⁡(π)\sin ( \pi )$ and $cos⁡(−π)\cos (- \pi )$ to $cos⁡(π)\cos ( \pi )$

Making the dataset first,

pi = torch.linspace(-np.pi/2, np.pi/2, steps=1000)
print(pi[:5])  # lower bound
print(pi[-5:]) # upper bound

sined = torch.sin(pi)
cosed = torch.cos(pi)
print(sined[0:5])
print(cosed[0:5])

tensor([-1.5708, -1.5677, -1.5645, -1.5614, -1.5582])
tensor([1.5582, 1.5614, 1.5645, 1.5677, 1.5708])
tensor([-1.0000, -1.0000, -1.0000, -1.0000, -0.9999])
tensor([-4.3711e-08,  3.1447e-03,  6.2894e-03,  9.4340e-03,  1.2579e-02])

Now using matplotlib to create the graph

import matplotlib.pyplot as plt

plt.plot(sined, label="sined")
plt.plot(cosed, label="cosed")
plt.legend()
plt.show()

Operations on 2D Tensors

The greyscale images are the best example of 2D tensors. Each pixel which you see as $w i d t h * h e i g h t$ are the $co l s * ro w s$ for the matrix.

In the above images, it is demonstrated how a binary image can be represented in a matrix. In case of grayscale image, the value of each element of the matrix would be in range of $0 - 255$

Just in case you are wondering how a RGB coloured image is represented, it is basically a 3D tensor where there are 3 matrix for each R, G and B channel. For example

Creating a random 2D tensor using torch.rand(*size) method.

NOTE: This is a general method, you can create a random tensor of any dimension using this method

t2 = torch.rand((3, 3))
print(t2)
print(t2.ndim)   # dimension of matrix is also called rank of matrix
print(t2.shape)
print(t2.numel())

tensor([[0.0376, 0.4297, 0.2987],
        [0.8009, 0.1815, 0.5538],
        [0.2482, 0.7099, 0.3132]])
2
torch.Size([3, 3])
9

The Tensor.numel() method used above returns the total number of the elements in the tensor

The indexing and slicing works same as 1D tensor, but there is a minor change. In 1D you were used to use [number_start:number_end] for slicing and [index] for getting element at particular index.

Here now you have rows and columns, so the syntax would be [index_row, index_col] to get the particular element at row and column in the matrix and [number_start_row:number_end_row, number_start_col:number_end_row].

print(t2[0, 0])
print(t2[1, 1])

tensor(0.0376)
tensor(0.1815)

The above code will give you the very first and middle element from the matrix. As shown in the following matrix

Getting an element with indexing will always give you a new tensor of 0D

t2[1:2, 1:]

tensor([[0.1815, 0.5538]])

To perform the matrix multiplication you can use either of them: Tensor.matmul(tensor2), torch.matmul(tensor1, tensor2), Tensor.mm(tensor2) or torch.mm(tensor1, tensor2)

x = torch.rand((3, 4))
y = torch.rand((4, 3))
print(x)
print(y)

print(x.matmul(y))
print(torch.mm(x, y))

tensor([[0.6413, 0.1338, 0.5066, 0.1618],
        [0.3807, 0.8555, 0.2187, 0.5024],
        [0.2771, 0.6381, 0.5671, 0.6934]])
tensor([[0.0263, 0.9461, 0.6314],
        [0.9180, 0.1586, 0.2589],
        [0.3363, 0.4529, 0.9433],
        [0.6760, 0.8877, 0.1171]])
tensor([[0.4195, 1.0009, 0.9363],
        [1.2086, 1.0409, 0.7270],
        [1.2525, 1.2358, 0.9563]])
tensor([[0.4195, 1.0009, 0.9363],
        [1.2086, 1.0409, 0.7270],
        [1.2525, 1.2358, 0.9563]])

I hope you have liked this post. Please share it with your friends and colleagues and help them learn the concepts of PyTorch. If you have doubts or any idea reach me out via following sources

Email: tbhaxor@gmail.com (Recommended)
Twitter: @tbhaxor
GitHub: @tbhaxor
LinkedIn: @gurkirat--singh
Instagram: @_tbhaxor_

GCP Essentials :: Cloud Marketplace

Gurkirat Singh — Wed, 23 Dec 2020 21:52:39 +0000

Suppose you want to spin up an application without worrying about configuration of deployment settings like virtual machine instances, storage or network settings, google cloud marketplace is what you are looking for. However, you can modify many of them before the launch.

You can visit this website and search for your application. https://cloud.google.com/marketplace

The marketplace also contains third-party enterprise applications that might be billable, for example MongoDB cluster.

The billing model would go like GCP RESOURCES CHARGES + APPLICATION CHARGES + TAXES = AMOUNT TO BE PAID, you will have to at least pay for the GCP resources you are using and some applications can be free of cost.

Note For paid applications, you will see the estimates (excluding networking costs since those will vary based on how you use the application) of their monthly charges before you launch them.

No more talks, let's "host a ghost blog using cloud marketplace"

Select your project from GCP console and goto, https://console.cloud.google.com/marketplace/browse

Browse wordpress and click on "Ghost"

So if you want to check the pricing, you can scroll down and see the detailed pricing schemes. Then click on Launch button

I have selected free tag, so here I would have to only pay for the GCP resources only

See how effectively you can configure your application. Select the options as per your needs, scroll down and hit "Deploy"

Wait for google to setup the application for you. Use the Deployment Manager to see the status of the deployment

After the deployment, you can configure the application as per your need

This is the at least you need to do to run the application :P

The best thing is, if you want to login the server or want more information related to deployment, google always backs your support

I am waiting to see what have you deployed using the marketplace and how you are using it. Hit me up at the following

Email: tbhaxor@gmail.com (Recommended)
Twitter: @tbhaxor
GitHub: @tbhaxor
LinkedIn: @gurkirat--singh
Instagram: @_tbhaxor_

PyTorch :: Understanding Tensors (Part 1)

Gurkirat Singh — Wed, 23 Dec 2020 01:46:39 +0000

In this post, you will start from the very basics of deep learning frameworks. TENSORS

So basically a neural network is the bunch of nodes that take one or more input, processes them and returns one or more output.

Table of Content

What are Tensors
Creating Tensors
Tensor Types and Their Conversions
Shapes and Dimensions
- Reshaping Tensors

What are Tensors

Tensors are the building blocks of a neural network. A PyTorch tensor is the generalized form of arrays in $n$ dimensions to run arbitrary computations on GPU. [READ MORE]

A tensor can be of any dimension. In this course you will learn about the following dimensions only

0D -> Scalar numbers like 0, 10, 20 etc. are 0-Dimensional tensors
1D -> Array of numbers like [1, 2, 3] or [20, 30, 10] etc.
2D -> Matrix of numbers like [[1, 2, 3], [2, 3, 4]]

Note During the process of learning, the network applies some tensor methods on these tensor values in order to gain the desired output.

Before creating and using tensors in PyTorch, install it by following the instructions from here: https://pytorch.org/get-started/locally/

Creating Tensors

You can create the tensors by importing torch and using torch.tensor(data) method.

import torch

t0 = torch.tensor(10)                     # 0-D tensor
t1 = torch.tensor([1, 2, 3, 4])           # 1-D tensor
t2 = torch.tensor([[1, 2, 3], [2, 3, 4]]) # 2-D tensor

print(t0)
print(t1)
print(t2)

tensor(10)
tensor([1, 2, 3, 4])
tensor([[1, 2, 3],
        [2, 3, 4]])

To convert it into numpy array, simply use Tensor.numpy() method and use it as you wish

print(t2.numpy())

array([[1, 2, 3],
       [2, 3, 4]])

Tensor Types and Their Conversions

PyTorch supports the following data-types of the tensors

To get the data type use Tensor.dtype property and Tensor.type() to get the PyTorch tensor type

print(t2.dtype)
print(t2.type())

torch.int64
torch.LongTensor

Note Difference between .dtype and .type() is better explained here

To explicitly create a tensor of specific type, either pass dtype while defining the tensor in torch.tensor method or use tensor constructor.

For example, here I am creating a float tensor by providing int32 data

tf0 = torch.tensor([1, 2, 3, 4], dtype=torch.float32)
print(tf0)
print(tf0.dtype)

tf1 = torch.FloatTensor([5, 6, 7, 8])
print(tf1)
print(tf1.dtype)

tensor([1., 2., 3., 4.])
torch.float32
tensor([5., 6., 7., 8.])
torch.float32

You can pass-in the the datatype in the Tensor.type([type]) method, in order to change the data-type of the existing tensor.

For example, changing float tensor to int32

tf0 = tf0.type(torch.int32) # after changing, it returns a new tensor object of that type
print(tf0.dtype)

torch.int32

Shapes and Dimensions

While training the model, you will deal with higher dimensions and neural network only accept the dimension which is defined at input layer while architecting the model.

The dimension basically tells whether the tensor is 0-D or 1-D or 2-D or even higher than that. Dimension of tensor is also called the rank of the tensor.

To get the size you can use Tensor.size() method or Tensor.shape property and to get the dimension of the tensor, use Tensor.ndimension() method or Tensor.ndim property.

print(t1.size())
print(t1.ndim)

print(t2.shape)
print(t2.ndimension())

torch.Size([4])
1
torch.Size([2, 3])
2

Reshaping Tensors

Sometimes working with neural network, you will face a situation when you are supposed to change the dimension of the tensor. This can be done by using Tensor.view(nrows, ncols) method of the tensor

For example, I have a tensor [[1, 2, 3], [2, 3, 4]] and I want to convert it to 2D with 1 row and 6 columns

tx = t2.view(1, 6)
print(tx)

tensor([[1, 2, 3, 2, 3, 4]])

Note The number of parameters in .view method is the total number of dimensions

# Converting 2D to 1D tensor
tx = t2.view(6)
print(tx)

tensor([1, 2, 3, 2, 3, 4])

There are special values for the view method. Suppose you don't know how many rows would be good while resizing your matrix, you can set it to -1 it will automatically adjust the rows for you. Same goes with columns.

# Telling PyTorch to keep the max 2 elements in one column and make as many rows as you want
tr = t2.view(-1, 2)
print(tr)

# Telling PyTorch to keep max 2 rows and adjust columns automatically
tc = t2.view(2, -1)
tc

tensor([[1, 2],
        [3, 2],
        [3, 4]])
tensor([[1, 2, 3],
        [2, 3, 4]])

Note Both the rows and columns can't be set to -1 at same time.

I hope you have liked this post. Please share it with your friends and colleagues and help them learn the concepts of PyTorch. If you have doubts or any idea reach me out via following sources

Email: tbhaxor@gmail.com (Recommended)
Twitter: @tbhaxor
GitHub: @tbhaxor
LinkedIn: @gurkirat--singh
Instagram: @_tbhaxor_

PyTorch :: Course Introduction

Gurkirat Singh — Wed, 23 Dec 2020 00:15:06 +0000

Hello friends,

This is my brand new series on Deep Learning with PyTorch. In this series you will learn the basics of deep learning and neural networks. Since this course is cantered towards the PyTorch library, I will not be discussing much deeper into what are neural networks and how they work or learn.

This course content is taken from coursera and I have included some more information based on my research and latest releases of PyTorch library.

You can still pursue the course on coursera, but here you will find more references and links to the original documentation. Also you can get the exclusive access to all the projects that I have created while learning PyTorch

If you have doubts or any idea reach me out via following sources

Email: tbhaxor@gmail.com (Recommended)
Twitter: @tbhaxor
GitHub: @tbhaxor
LinkedIn: @gurkirat--singh
Instagram: @_tbhaxor_

So let's dive into the ocean of deep learning using PyTorch.