Definition of a Cycle in a Linked List

A linked list can consist of a cycle if a tail node of the linked list points to another node in the list. Let us see a small example to understand the concept of cycle in a linked list.

In the above figure, you can see that the tail node of the linked list, instead of pointing to NULL, points to another node — the second node in the list. If such a scenario arises, we say there is a cycle or a loop in a list.

Initialization and Setup

We will first begin by initializing the nodes and constructing the linked list.

from linked_list import Node, LinkedList
 
node1 =  Node(5)
node2 =  Node(6)
node3 =  Node(7)
node4 =  Node(8)
node5 =  Node(9)
 
 
ll = LinkedList()
 
ll.insert_back(node1)
ll.insert_back(node2)
ll.insert_back(node3)
ll.insert_back(node4)
ll.insert_back(node5)

Now, we will connect the fifth node to the 3rd node forming a cycle.

node5.next = node3

Approach 1: Naive Approach

We will now look at a simple approach to implement the logic to find out if the list consists of a cycle or not. One approach would be to store the address of the node in a dictionary as we traverse through the list and as soon as we come across a node whose address was already in the dictionary, we can say that there was a cycle in the list. Let us see how we can implement this in Python

 
addresses = {}
temp_node = node1
while (temp_node):
   address = id(temp_node)
   print(address)
   if address not in addresses:
       addresses[address] = 1
   else:
       print('cycle in a linked list')
       print(temp_node.data)
       break
   temp_node = temp_node.next

The disadvantage of the previous approach is that it takes 0(n) space complexity. Can we solve this problem in O(1) space complexity?

Approach 2: Floyd’s Cycle Detection Algorithm

We can solve this problem by initializing two pointers, a slow pointer, and a fast pointer. On every iteration, we increment the slow pointer by 1 and the fast pointer by 2. We then check if the slow pointer is equal to the fast pointer i.e. do both the pointers point to the same node. If that is the case, we can say that there is a cycle or a loop in a linked list. Once we find the cycle we can break out of the while loop. 

Demonstration

Let us imagine we have a list with 5 nodes as illustrated in the figure below. As you can see the tail node i.e. the node with a value of 9 is pointing to the node with the value 7 or the 3rd node in the list, thereby forming a loop or a cycle.

Iteration 1:  

In the first iteration, the slow pointer is incremented by 1 and the fast pointer by 2. As you can see in the figure below, the slow pointer is now pointing to the node with the value 6 and the fast pointer is pointing to the node with the value 7.

Iteration 2:

In the second iteration  the slow pointer points to the node with the value 7 and the fast pointer points to the node with the value 9 or the last node.

Iteration 3:

In the third iteration we observe that both the slow and fast pointers are pointing to the same  node i.e. the node with the value 8. In this case, we can conclude that there is a cycle in a list.

Let us know see how we can implement the adobe logic in Python. 

We first initialize the slow pointer and the fast pointer pointing to the head node or the first node. We then run a while loop, and we run the loop as long as the slow pointer is valid, the fast pointer is valid and the next value of the fast pointer is valid. We then keep incrementing the slow and fast pointers by 1 and 2 respectively and if both the pointers have the same address value, we break out of the loop and print that there was a cycle in a linked list. You can find the entire logic below.

slow_ptr = node1
fast_ptr = node1
 
while (slow_ptr and fast_ptr and fast_ptr.next):
   slow_ptr = slow_ptr.next
   fast_ptr = fast_ptr.next.next
   if slow_ptr == fast_ptr:
       print('loop in a linked list', slow_ptr.data)
       break
   else:
       print(slow_ptr.data, fast_ptr.data)

This algorithm is also called the Floyd’s cycle detection algorithm.

Conclusion

In this tutorial, we saw how we can detect a cycle in a loop using the Floyd’s cycle detection algorithm. This algorithm can detect a loop in O(1) space complexity and O(n) time complexity.

The post [Floyd’s Algorithm] How to Detect a Cycle in a Linked List in Python? appeared first on Be on the Right Side of Change.

Imagine you are working on an application  where you have a list of numbers and would like to output the reciprocal of the numbers. If by mistake the list consists of 0, then the program would crash since we are diving 1 by 0 which will raise an exception. We can implement this in a bug free manner by using a try and except block.

We can achieve this by the following two steps

1. Put the logic of taking the reciprocal of the number in try block
2. Implement an exception block that is executed wherever the number is 0. Continue with the rest of the logic 

Without a try-except Block

Let us first implement the logic using a simple for loop. As you can see in the output below, the program crashed when the number was 0

numbers = [12, 1, 0, 45, 56]
for number in numbers:
    print('result is {}'.format(1/number))

Output

result is 0.08333333333333333
result is 1.0

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-27-c1f2d047aa92> in <module>()
      1 for number in numbers:
----> 2   print('result is {}'.format(1/number))

ZeroDivisionError: division by zero


With a try-except Block

Let us now see how we can safely ignore an exception

numbers = [12,1,0,45,56]
for number in numbers:
    try:
        print('result is {}'.format(1/number))
    except Exception as e:
        print('Ignoring Exception', e)

Output

result is 0.08333333333333333
result is 1.0
Ignoring Exception division by zero
result is 0.022222222222222223
result is 0.017857142857142856

Summary

In this blog post you learned how to safely ignore exceptions in Python. You learnt how to use a try and except block and continue with the program if an exception is encountered.

The post How to Ignore Exceptions the Pythonic Way? appeared first on Be on the Right Side of Change.

We will start by loading the Boston household data and process the data to visualize the median price of the house.

1. Load the data
2. Import Libraries and plot data points
3. Set the y-axis limit

Load the data

Let us begin by loading the data using the pandas library

import matplotlib.pyplot as plt
import pandas as pd
data = pd.read_csv('sample_data/california_housing_test.csv')

Import Libraries and Plot Data Points

house_values = data['median_house_value'].values
house_values = sorted(house_values)

We now have extracted the median_hoise_value column and sorted the values in ascending order. Let us now being plotting the data

Set the y-axis Limit

paramValues = range(len(house_values))
plt.figure(figsize=(8.5,11))
plt.plot(paramValues,house_values)
plt.title('Median house price')
plt.ylabel('Median Price')
plt.xlabel('Range')
plt.grid(True)
plt.show()

Change y-axis Limit

paramValues = range(len(house_values))
plt.figure(figsize=(8.5,11))
plt.plot(paramValues,house_values)
plt.title('Median house price')
plt.ylabel('Median Price')
plt.xlabel('Range')
plt.grid(True)
plt.ylim((None,400000))
plt.show()

By using the plt.ylim() function we can change the limit of the y-axis. In the above example setting the second parameter to 400000 we have to change the maximum value of the y axis. Similarly, we can change the minimum value of the y-axis by changing the first argument in the plt.ylim() function

Summary

In this blog post you have learned how to set the y-axis limit in matpltotlib.  I hope you found the post informative.

The post How to Set the y-Axis Limit in Python Matplotlib appeared first on Be on the Right Side of Change.

Related Tutorial: 5 Minutes to Pandas

There are 5 ways to extract value from a cell of a Pandas DataFrame

1. Extract data using iloc or indexing
2. Extract data using iat
3. Extract data using loc
4. Extract data using at
5. Extract data using data_frame.values[]

Loading the Dataset

We will examining the above methods by loading a sample dataset. I have used the California housing dataset that you can download from this link. 

import pandas as pd
data = pd.read_csv('sample_data/california_housing_test.csv')

Let us see the columns of the dataset

data.head(5)

Output

We can see the first 5 rows of the dataset. The dataset has 9 columns. We will now examine the 5 different methods to extract the 2nd row value of the latitude column 

Method 1: Extract Data using iloc or Indexing

We can use normal indexing the extract the value. 

data.iloc[1]['latitude']

Since the indexing starts from 0, the 1st index is used to get the contents for the 2nd row. Once we extract the row, we can extract any column value that we want. In our case we wanted to get the latitude value. We get the following output.

Output

Method 2: Extract Data using iat

We will not look at another method to extract the latitude value from the 2nd row.

We can call the iat method of the pandas dataframe to get the cell value. The iat value is called using the row index and column index as an argument. In our example latitude is the 1st column index and for the 2nd row we will use the 1st Index. 

data.iat[1,1]

     Output

34.26

Method 3: Extract Data using loc

We can use the loc method to get the value. The loc method unlike the ioc method can be used by passing in a string as an argument if the index values are strings. In our example since all indexes are numerical values, we can do the following

data.loc[1]['latitude']

      Output

34.26

Method 4: Extract Data using at

The fourth way to extract a value from the cell is using the at method. The at method takes in the row index as an argument and the column name as the second argument. 

data.at[1,'latitude']

   Output

34.26

Method 5: Extract Data using data_frame.values[]

The last method to extract the value from a specific cell is to first convert the frame into a series by using the column name we are interested in getting the value from and then converting the series into a list using the values property. We can then use normal row indexing to get the value from a specific row.

data['latitude'].values[1]

 Output

34.26

Recommended Tutorial: Python Find Longest String in a DataFrame Column

Summary

In this blog post, we saw 5 methods to extract the value from a pandas dataframe. Depending on the use case, we can use any of the above 5 methods to get a value from a cell.

Programming Humor

Programming is 10% science, 20% ingenuity, and 70% getting the ingenuity to work with the science.

~~~

• Question: Why do Java programmers wear glasses?
• Answer: Because they cannot C# …!

Feel free to check out our blog article with more coding jokes.

The post How to Get A Value From a Cell in a Pandas DataFrame appeared first on Be on the Right Side of Change.

Changing directories using the os.chdir function

The easiest way to change the working directory in Python is importing the os package and calling the chdir() function. The function takes in the target directory as an input parameter

Let us see an example

1. Get the current working directory

Let us first see the current working directory in Python. We can achieve this by calling the os.getcwd() function

import os
os.getcwd()

We get the following output when we execute the above two lines

/content

2. Get the contents of the current working directory

 We will now execute the function call to get the contents of the working directory. We can do this by calling the following function in Python

os.listdir()

We get the following output

['.config', 'sample_data']

3. Navigate to target directory

    We will now use the os.chdir() function to navigate to the ‘sample_data’ directory

os.chdir('sample_data')

  We can now again call the os.getcwd() function to verify if the directory was changed.

os.chdir('sample_data')

  We get the following output

/content/sample_data   

Changing the Working Directory using Context Manager

The second approach to change the working directory is using a context manager. Let us see an example and the benefits of using a context manager.

In the previous example, the working directory changes even outside a function. Most of the time, we would want to run out logic inside a function and once we exit the function, we would like to return the previous working directory. A context manager helps us to achieve this without any errors

1. Import the libraries

Let us first import the libraries

from contextlib import contextmanager
import os

2. Function to change directories

We will now implement a function call change_path() using the @contextmanager decorator function.

@contextmanager
def change_path(newdir):
    old_path = os.getcwd()
    os.chdir(os.path.expanduser(newdir))
    try:
        yield
    finally:
        os.chdir(old_path)


3. Call the function change_path

with change_path('sample_data'):
    print(os.getcwd())

We get the following output

/content/sample_data

If we now call the os.getcwd() we get the following output

/content

As you can see outside the context of change_path we are in the previous directory. We can do the processing by changing the directory inside the context of the change_path function

Summary

In this tutorial we looked at two ways to change the working directory in Python.

1. Using getcwd() we can change the directory, but the directory is changed also outside the scope of a function
2. Using contextmanager we can change the directory in an error-free manner and outside the context of a function, the directory is not changed.

The post How to Change the Working Directory in Python appeared first on Be on the Right Side of Change.

1. How to install TensorFlow in a virtual environment
2. How to activate your environment in Jupyter Notebook
3. How to use TensorFlow in a Jupyter Notebook

How to install TensorFlow in a virtual environment

In order to use TensorFlow in a Juypter notebook, we need to create an independent environment to manage our dependencies. We will begin by creating an anaconda environment. We first begin by creating a directory with an environments.yml file and a notebooks directory. We will use the notebooks directory to create our notebook for TensorFlow experiments. The environments.yml file is used to manage our dependencies

As a next step, you can open a text-editor of your choice and add the following line in your environments.yml file

name: tensorflow-development
channels:
- anaconda
- conda-forge
- defaults
 
dependencies:
 - python=3.7
 - numpy
 - matplotlib
 - pandas
 - tensorflow
 - notebook
 - nb_conda_kernels
 - jupyter_contrib_nbextensions

We will now create a new environment called tensorflow-development using the following command in your terminal:

conda env create -f environment.yml

How to activate your environment in Jupyter Notebook

Once you have created your environment let us now see how we can activate our environment

conda activate tensorflow-development

How to use TensorFlow in a Jupyter Notebook

We will now execute the following command to start the Jupyter notebook

jupyter notebook

We can now choose the environment which we created and start the Jupyter notebook

We can now navigate to notebooks/ and create our notebook. We will test to see if TensorFlow was installed successfully. We will import the TensorFlow library and print the version number of the library.

Summary

In this blog post, we learned how to install the TensorFlow library in a managed python environment. We then had to look at how to use Tensorflow in a Jupyter notebook environment.

The post How to Run TensorFlow in a Jupyter Notebook? appeared first on Be on the Right Side of Change.

A doubly linked list, unlike a singly linked lists consists of a data value along with a next and previous pointer. Let us see a simple example of a doubly linked list.

In the above figure you can visualize a pictorial representation of a doubly linked list. Every node has a pointer to the next node and a pointer to the previous node represented by the next and prev pointer respectively. 

Operations on a Doubly Linked List

Let us know explore some common operations we can perform on a doubly linked list

1. Insertion
2. Deletion
3. Traversal

Let us first being by defining a node class which contains the next and previous pointer. Whenever a new node is created the two pointers are set to null initially.

class Node(object):
   def __init__(self, value):
       self.data = value
       self.prev = None
       self.next = None

We began by initializing the constructor of the node class and initializing and declaring the data value, the next pointer and the prev pointer.

You can create a node as follows

node = Node(12)

This will create a node with the value 12.

Let us now begin by defining the doubly linked list and implementing the common operations we can perform on it

We begin by declaring a class called DoublyLinkedList and initializing the head pointer to None

class DoublyLinkedList(object):
   def __init__(self):
       self.head = None

Inserting an element in a Doubly Linked List

We will now look at how we can insert a new node in a doubly linked list

There are 3 scenarios that can occur while inserting a node in a list.

1. Inserting at the front of the list
2. Inserting at the back of the list
3. Inserting at a random position in the list

Inserting a node at the front of the list

We start by defining a function called insert_front which takes in a node as an input parameter. We then check if the list is empty or not. If the list is empty we assign the head pointer to the newly created node. If the list is not empty i.e. the head pointer is not None we assign the next pointer of the newly created node to the head of the list and the prev pointer of the head to the node. We then reassign the head pointer to point to the newly created node.

def insert_front(self, node):
       if self.head is not None:
           node.next = self.head
           self.head.prev = node
           self.head = node
       else:
           self.head = node

Inserting a node at the back of the list

We will now look at how to insert a node at the end of the list or the tail of the list.

def insert_back(self, node):
        if self.head is not None:
            current_node = self.head
            while(current_node.next is not None):
                current_node = current_node.next
            current_node.next = node
            node.prev = current_node
        else:
            self.head = node

We define a function called insert_back which takes in a node as an input parameter. We again check if the list is empty or not. If the list is not empty we point the head to the new node. If the list is not empty i.e. there are already some nodes present in the list, we  traverse the list till we reach the tail of the list. Once we are at the tail of the list we assign the next pointer of the last node to point to the new node and the previous pointer of the node to point to the previous tail of the list. At the end of this operation the new node becomes the tail of the list.

Inserting at a random position in the list

We will now look at how to insert a new node in a list at a random position. We first check if the list is empty or not. If the list is empty we insert the node at the front of the list by calling the insert_front function we had implemented. If the list is not empty then we initialize a counter variable and initialize the current node to point to the head of the list. We then go through the list and keep updating the counter and the current node. As soon as we reach the index position where we would like to insert the node, we point the node to the next pointer of the current node, the previous pointer of the node to the current node, and the next pointer of the current node to the newly created node. 

We also check if the next of the new node is the last element or node. If it is not the last element in the list, we point the previous pointer of the next node to the new node.  

def insert(self, node, index):
       if self.head is not None:
           current_counter = 1
           current_node = self.head
           while current_node is not None:
               if current_counter == (index-1):
                   node.next = current_node.next
                   node.prev = current_node
                   current_node.next = node
                   if node.next is not None:
                       node.next.prev = node
               current_node = current_node.next
               current_counter += 1
       else:
           print('List is empty')
           self.insert_front(node)

Deleting an element in a DLL

We will now look at another important operation we can perform on a doubly linked list. We begin by defining a function called  delete. The function will take the node value we would like to delete from the list. We then check if the list is empty or not. If the list is empty then we return from the function. If the list is not empty, we will check if the node we would like to delete is the head node or not. If it is the head node we delete the node and assign the head pointer to None. If the node we would like to delete is not the head node, we will first traverse through the list to find the node, once we find the node in the list we will first declare the node  as a temporary node. The next pointer of the previous element in the list will point to the next pointer of the temporary node and the previous pointer of the next node in the list will point to the previous node. We then assign the temporary node to None and delete the node. 

def delete(self, value):
       if self.head is None:
           print('Doubly Linked List is empty')
           return
       if self.head.next == None:
           if self.head.data ==  value:
               temp_node = self.head
               self.head = None
               del temp_node
               return
           else:
               print("Element is not found in our list")
               return
       else:
           temp_node = self.head.next
           while temp_node is not None:
               if temp_node.data == value:
                   temp_node.prev.next = temp_node.next
                   temp_node.next.prev = temp_node.prev
                   temp_node = None
                   return
               temp_node = temp_node.next
           if temp_node.data == value:
               temp_node.prev.next = None
               del temp_node
               return
           print("Element is not found in the list")

Summary

In this blog post you learned how to implement a doubly linked list in python. We also looked at how to perform some common operations on a list like insertion and deletion.

You can find the entire code below

class Node(object):
   def __init__(self, value):
       self.data = value
       self.prev = None
       self.next = None
 
class DoublyLinkedList(object):
   def __init__(self):
       self.head = None
 
   def insert_front(self, node):
       if self.head is not None:
           node.next = self.head
           self.head.prev = node
           self.head = node
       else:
           self.head = node
 
   def insert_back(self, node):
       if self.head is not None:
           current_node = self.head
           while(current_node.next is not None):
               current_node = current_node.next
           current_node.next = node
           node.prev = current_node
       else:
           self.head = node
 
 
   def insert(self, node, index):
       if self.head is not None:
           current_counter = 1
           current_node = self.head
           while current_node is not None:
               if current_counter == (index-1):
                   node.next = current_node.next
                   node.prev = current_node
                   current_node.next = node
                   if node.next is not None:
                       node.next.prev = node
               current_node = current_node.next
               current_counter += 1
       else:
           print('List is empty')
           self.insert_front(node)
 
 
   def delete(self, value):
       if self.head is None:
           print('Doubly Linked List is empty')
           return
       if self.head.next == None:
           if self.head.data ==  value:
               temp_node = self.head
               self.head = None
               del temp_node
               return
           else:
               print("Element is not found in our list")
               return
       else:
           temp_node = self.head.next
           while temp_node is not None:
               if temp_node.data == value:
                   temp_node.prev.next = temp_node.next
                   temp_node.next.prev = temp_node.prev
                   temp_node = None
                   return
               temp_node = temp_node.next
           if temp_node.data == value:
               temp_node.prev.next = None
               del temp_node
               return
           print("Element is not found in the list")
 
   def display(self,):
       current_node = self.head
       while current_node is not None:
           if current_node.next is None:
               print(current_node.data,  end=' ', flush=True)
           else:
               print(current_node.data,  end='-->', flush=True)
           previous_node = current_node
           current_node = current_node.next
 
       print('\n')
       print('List in reverse order')
      
       while previous_node is not None:
           if previous_node.prev is None:
               print(previous_node.data,  end=' ', flush=True)
           else:
               print(previous_node.data,  end='-->', flush=True)
           previous_node = previous_node.prev
       print('\n')
 
if __name__ == "__main__":
   node1 = Node(12)
   node2 = Node(13)
 
   dll = DoublyLinkedList()
   dll.insert_front(node1)
   dll.insert_front(node2)
   dll.display()
 
   dll.insert_back(Node(14))
   dll.insert_back(Node(26))
 
   dll.insert_front(Node(1))
 
 
   dll.display()
 
 
 
   dll.insert(Node(2), 2)
   dll.insert(Node(5), 3)
 
   dll.display()
 
 
   print('Deleting node')
   dll.delete(5)
   dll.display()

The post Doubly Linked List in Python appeared first on Be on the Right Side of Change.

Introduction

Linked list is one of the most fundamental data structure in programming. Imagine you are building a directory of image files and each of these files are linked to each other. How could we model this problem? There are various data structures at our disposal to solve this problem. You could use an array to store the files in a contiguous block of memory. The advantage of using an array is its quick access time. While an array does help us in accessing the files in O(1) time, there are some disadvantages of using an array if we would like to insert a new file or delete a new file. A linked list helps us in inserting and deleting an element in constant time.

A linked list is represented by a collection of nodes and each node is linked to the other node by using a pointer.  Figure 1 demonstrates the concept of a linked list.

                Figure 1: Linked List

As you can see in Figure 1, a linked list is created by connecting the next pointer of a node with another node. Let us now get started by opening our editor and constructing a singly linked list in Python.

A linked list  has a collection of nodes, so we first start by constructing a Node class

class Node(object):
   def __init__(self, value):
       self.data = value
       self.next = None

The Node class has two member variables — the data and the pointer called next which points to the next node. Whenever a new node is created, the next pointer will be set to a None value.

Now let us begin by constructing the Linked List class. The class will be composed of the following functionalities

1. Inserting an element at the front of the Linked List
2. Inserting an element at the back or the tail of the Linked List
3. Deleting an element at a specified index in the Linked List
4. Searching the Linked List for a specified data value
5. Displaying the Linked List

Let us begin by constructing the Linked List and initializing the member variables

class LinkedList(object):
   def __init__(self):
       self.head = None

Operations on a Linked list

Next, you’ll learn about all the discussed linked list operations—and how to implement them in Python!

Inserting an element at the front of the Linked List

In order to insert a new node at the front of the list we first need to check if the list is empty or not. We do this by checking the head of the list. If the list is empty then we can point the head to the newly created node. If, however, the list is not empty, we will point the next value of the newly created node to the head of the linked list, and we will reassign the head pointer to point to the newly created node. The code snippet below  demonstrates how you can implement this functionality.

class LinkedList(object):
   def __init__(self):
       self.head = None
 
   def insert_front(self, node):
       if self.head is not None:
           node.next = self.head
           self.head = node
       else:
           self.head = node

Inserting an element at the end of the list

In order to insert an element at the end of the list we need to traverse the list till we reach the tail of the list and as soon as we reach the tail of the list we point the next pointer of the tail to the newly created node.

def insert_back(self, node):
       if self.head is not None:
           current_node = self.head
           while current_node.next is not None:
               current_node = current_node.next
           current_node.next = node
       else:
           self.head = node

Deleting an element at a specified index in the Linked List

Now we will look at how to delete an element from the linked list given an index value.

There are three conditions we need to check if we would like to delete a node from a linked list.

1. Deleting a node if the linked list is empty: We will first check if the linked list is empty or not. If the list is empty we print a message that the linked list is empty and return from the function.
2. Deleting the head of the linked list: The second condition arises when we would like to delete the first node or in other words the head of the linked list. To remove the head of the linked list we first create a temporary node to point to the head of the node and then reassign the head pointer to the next node of the original head. We then delete the temporary node.
3. Deleting a node at an arbitrary position: In order to delete a node at an arbitrary position we traverse through the linked list and check if the value that we would like to delete matches with that of the current node. If a match is found we reassign the previous node’s next pointer to the current node’s next node. We then delete the current node.

def delete(self, value):
       if self.head is None:
           print('Linked List is empty')
           return
       if self.head.data == value:
           node_to_delete = self.head
           self.head = self.head.next
           del node_to_delete
           return
       # deletion at arbitary position
       current_node = self.head
       while current_node is not None:
           if current_node.next.data == value:
               temp_node = current_node.next
               current_node.next = temp_node.next
               del temp_node
               return
           current_node = current_node.next

Searching the Linked List for a specified value

We will now look at searching for a given value in a linked list. In order to achieve this we start at the head of the linked list and at every iteration we check for the node’s value. If a match is found we print the location of that node by keep track of a counter variable that we have defined. If no match is found we jump to the next node and repeat the steps to check for a match.

def search(self, value):
       counter = 1
       current_node = self.head
       while current_node is not None:
           if current_node.data == value:
               print('Node with value {} found at location {}'.format(value, counter))
               return
           current_node = current_node.next
           counter += 1
       print('Node with value {} not found'.format(value))

Displaying the Linked List

We will create a function called display to traverse through the linked list and print the data value of the node. Once we print the value we jump to the next node by updating the value of the current node.

def display(self,):
       current_node = self.head
       while current_node is not None:
           if current_node.next is None:
               print(current_node.data,  end=' ', flush=True)
           else:
               print(current_node.data,  end='-->', flush=True)
           current_node = current_node.next
       print('\n')

Demonstration

Let us now see all the functionalities in action. We start by creating four nodes with the following values

We then create an instance of the LinkedList class and insert the above nodes at the back of the linked list.

node1 = Node(12)
node2 = Node(13)
node3 = Node(14)
node4 = Node(15)
 
ll = LinkedList()
ll.insert_back(node1)
ll.insert_back(node2)
ll.insert_back(node3)
ll.insert_back(node4)
ll.display()

We can see the output as follows

12-->13-->14-->15

Next we will insert a node at the front of the linked list as follows.

node5 = Node(1)
ll.insert_front(node5)
ll.display()

On calling the display function, we get the following output

1-->12-->13-->14-->15 

Now we will look at the search functionality to search for a node with a specific data value and get the position of that node in the linked list.

ll.search(12)
ll.search(1)
ll.search(5)
ll.search(15)

As we can see in the output below we can observe that the node with the value 12 is at position 2, the node with the value 1 is at the first position, the node with the value 5 is not there in the list and the node with the value 15 is located at the position 5.

• Node with value 12 found at location 2
• Node with value 1 found at location 1
• Node with value 5 not found
• Node with value 15 found at location 5

We will now delete a node with a given value

 
ll.delete(12)
ll.display()

As we can see in the output below we were able to delete the node with the value 12 and update its previous pointer i.e. the node with the value 1 now points to the node with the value 13.

1-->13-->14-->15 

As a last step we will see what happens if we insert a new node at the specific location. In the example below we will try to insert a node with value 12 at the position 2, delete the node with the value 15 and 1 and observe the output after each step.

ll.insert(Node(12), 2)
ll.display()
 
ll.delete(15)
ll.display()
 
ll.delete(1)
ll.display()

We get the following output

1-->12-->13-->14-->15 
1-->12-->13-->14 
12-->13-->14 

You can see the entire code below

class Node(object):
   def __init__(self, value):
       self.data = value
       self.next = None
 
class LinkedList(object):
   def __init__(self):
       self.head = None
 
   def insert_front(self, node):
       if self.head is not None:
           node.next = self.head
           self.head = node
       else:
           self.head = node
 
   def insert_back(self, node):
       if self.head is not None:
           current_node = self.head
           while current_node.next is not None:
               current_node = current_node.next
           current_node.next = node
       else:
           self.head = node
 
   def insert(self, node, index):
       if self.head is not None:
           current_counter = 1
           current_node = self.head
           while current_node is not None:
               if current_counter == (index - 1):
                   node.next = current_node.next
                   current_node.next = node
               current_node = current_node.next
               current_counter +=1
       else:
           print('List is empty')
           self.insert_front(node)
 
   def search(self, value):
       counter = 1
       current_node = self.head
       while current_node is not None:
           if current_node.data == value:
               print('Node with value {} found at location {}'.format(value, counter))
               return
           current_node = current_node.next
           counter += 1
       print('Node with value {} not found'.format(value))
 
 
 
   def delete(self, value):
       if self.head is None:
           print('Linked List is empty')
           return
       if self.head.data == value:
           node_to_delete = self.head
           self.head = self.head.next
           del node_to_delete
           return
       # deletion at arbitary position
       current_node = self.head
       while current_node is not None:
           if current_node.next.data == value:
               temp_node = current_node.next
               current_node.next = temp_node.next
               del temp_node
               return
           current_node = current_node.next
      
 
   def display(self,):
       current_node = self.head
       while current_node is not None:
           if current_node.next is None:
               print(current_node.data,  end=' ', flush=True)
           else:
               print(current_node.data,  end='-->', flush=True)
           current_node = current_node.next
       print('\n')
 
  
 
 
 
if __name__ == "__main__":
   node1 = Node(12)
   node2 = Node(13)
   node3 = Node(14)
   node4 = Node(15)
 
   ll = LinkedList()
   ll.insert_back(node1)
   ll.insert_back(node2)
   ll.insert_back(node3)
   ll.insert_back(node4)
 
   ll.display()
 
   node5 = Node(1)
   ll.insert_front(node5)
   ll.display()
   ll.search(12)
   ll.search(1)
   ll.search(5)
   ll.search(15)
 
   ll.delete(12)
   ll.display()
 
   ll.insert(Node(12), 2)
   ll.display()
 
   ll.delete(15)
   ll.display()
 
   ll.delete(1)
   ll.display()

Conclusion

In this tutorial we saw how to implement a linked list from scratch. We then saw how to do some common operations like insertion, deletion, search and traversal on a linked list. Linked Lists have an advantage when we would like to insert or delete a node from our list. We can achieve both these tasks in constant time. In the next tutorial we will look at some common linked list problems and how to solve them efficiently. 

The post Linked Lists in Python appeared first on Be on the Right Side of Change.

Getting Started

Let us get started by installing the libraries needed to build our application.

We will create a virtual environment for development purpose. Using a virtual environment gives us the flexibility to separate dependencies for different Python projects.

Go to a directory where you would like to create this project and in a separate terminal execute the following command

python3 -m venv fastapi-env

Once you have the environment setup, we can activate the environment by executing the following command

source fastapi-env/bin/activate

Now your environment is activated, and we can begin by installing the necessary dependencies for our project.

Let us begin by creating a requirements.txt file which will include all the libraries that we would be using in our project.

We would be needing the FastAPI library and the sklearn library for running our regression model.

Open a new file, name it requirements.txt and insert the following lines:

# requirements.txt
fastapi
uvicorn
sklearn

You can now install the libraries by executing the following command

pip3 install -r requirements.txt

Building a Linear Regression Model

We will be using a trained linear regression model to predict the quantitative measure of disease prediction. You can use the following link to train a linear regression model. Once you have the model trained you can save the model using the joblib library

from joblib import dump, load
dump(regr , 'model.joblib')

We save the model in the current directory and give it a name–in our case we have given the model a name, model.joblib.

Serving Your Model

Now we begin by understanding how FastAPI works and how we can implement a simple API to serve a machine learning request.

We begin by importing the libraries

from fastapi import FastAPI
from joblib import load
import numpy as np

We then load our model and declare an instance of the FastAPI class. We store this in a variable called app.

app = FastAPI()
model = load('model.joblib')

We then implement a function for our index route. Whenever a user or a client tries to access the index route, the function root() is called and a “Hello World” message is sent back.

@app.get("/")
async def root():
   return {"message": "Hello World"}

You can run your app by using the uvicorn library which is an asynchronous server which spins up your app.

if __name__ == '__main__':
   uvicorn.run(app, host='127.0.0.1', port=8000)

Once your app is running we can go to localhost:8000 and see the message “Hello World” displayed

We will now implement the predict function and since we need to send a json file with our data we will define it as post request using the @app.post decorator function.

@app.post("/predict")
def predict(data_diabetes:float):
   data = np.array([[data_diabetes]])
   prediction = model.predict(data)
   return {
       'prediction': prediction[0],
   }

As you can see in the above code snippet, first the data is transformed into a NumPy array since our model expects an array of shape 1×1. We can these use this transformed vector value to call the predict function of the model, which will return the prediction or the quantitative metric of progression of diabetes.

Let us see the entire code in action

from fastapi import FastAPI
from joblib import load
import numpy as np
app = FastAPI()

model = load('model.joblib')



@app.get("/")
async def root():
   return {"message": "Hello World"}


@app.post("/predict")
def predict(data_diabetes:float):
   data = np.array([[data_diabetes]])
   prediction = model.predict(data)
   return {
       'prediction': prediction[0],
   }


if __name__ == '__main__':
   uvicorn.run(app, host='127.0.0.1', port=8000)

Calling Your Endpoint

You can call this endpoint using a client library in Python or using a simple curl command to test the functionality of our application.

curl -X POST "http://localhost:8000/predict?data_diabetes=0.07786339" -H  "accept: application/json" -d ""

You get the following response back

{"prediction":225.97324232953468}

The model outputted a value of 225.97324 and this was sent back as a response to our client.

Conclusion

In this blog post you learned how to deploy a simple machine learning model in FastAPI. FastAPI is a powerful web framework to deploy and build scalable Python applications.

The post Deploying a machine learning model in FastAPI appeared first on Be on the Right Side of Change.

Proportional Sampling

Let us take an example of tossing a die to better understand the concept of proportional sampling. An unbiased die is a die in which the probability of getting a number between 1 and 6 is equal. Let us now imagine that the die is biased i.e a weight value is given to each side of the die.

Proportional sampling is a technique in which the probability of selecting a number is proportional to the weight of that number. So, for instance if we run  an experiment  of tossing a die 100 times, then the probability of getting a 6 would be the lowest since the weight value of the side 6 is 10 which is the lowest amongst all other weight values. On the other hand, the probability of getting a 4 would be the highest since the weight value for 3 is 60 which is the highest amongst all other values.

There are 3 essentials steps to proportionally sample a number from a list.

1. Computing the cumulative normalized sum values
2. Choosing a random value from uniform distribution
3. Sampling a value

Cumulative Normalized Sum

In order to compute the cumulative normalized sum value we first need to calculate the total sum of the weight values and then normalize the weight values by dividing each weight value by the total sum. After normalizing the weight values, we will have all the values between 0 and 1 and the sum of all the values will always be equal to 1.

Let us declare a variable called dice and weights which represents the 6 sides of the die and the corresponding weight values

dice = [1, 2, 3, 4, 5, 6]
weights = [20, 12, 60, 58, 33, 10]

We will now compute the sum of all weights and store it in a variable called total_sum. We  can use the in-built sum function to do this.

total_sum = sum(weights)
normalized_weights = [weight/total_sum for weight in weights]
print(normalized_weights)

The normalized weights have values between 0 and 1 and the sum of all the values is equal to 1

[0.10362694300518134, 0.06217616580310881, 0.31088082901554404, 0.3005181347150259, 0.17098445595854922, 0.05181347150259067]

The cumulative sum is used for monitoring change detection in a sequential data-set. Let us denote the cumulative sum by a variable called weight_cum_sum and computing it as follows

weight_cum_sum[0] = normalized_weights[0]
weight_cum_sum[1] = weight_cum_sum[0] +  normalized_weights[1]
weight_cum_sum[2] = weight_cum_sum[1] +  normalized_weights[2]
weight_cum_sum[3] = weight_cum_sum[2] +  normalized_weights[3]
weight_cum_sum[4] = weight_cum_sum[3] +  normalized_weights[4]
weight_cum_sum[5] = weight_cum_sum[4] +  normalized_weights[5]

We can do this efficiently in python by running a for loop and appending the cumulative sum values in a list

cum_sum = [normalized_weights[0]]
for i in range(1, len(normalized_weights)):
    cum_sum.append(cum_sum[i-1] +  normalized_weights[i])

If we print cum_sum, we will get the following values

[0.10362694300518134, 0.16580310880829013, 0.47668393782383417,  0.7772020725388601,  0.9481865284974094, 1.0]

Choosing a random value

Now that we have calculated the cumulative sum of the weight values, we will now randomly choose a number between 0 and 1 from a uniform distribution. We can do this by using the uniform function from the random module in python. We will denote this number by r.

from random import uniform
r = uniform(0,1)

Sampling

We will now loop through the cum_sum array and if the value of r is less than or equal to the cum_sum value at a particular index, then we will return the die value at that index

for index, value in enumerate(cum_sum):
    if r <= value:
      return dice[index]  

You can see the entire code below

from random import uniform

def proportional_sampling(dice, weights):
    total_sum = sum(weights)
    normalized_weights = [weight/total_sum for weight in weights]
    cum_sum = [normalized_weights[0]]
    r = uniform(0,1)
    for i in range(1, len(normalized_weights)):
        cum_sum.append(cum_sum[i-1] + normalized_weights[i])
    for index, value in enumerate(cum_sum):
        if r <=  value:
            return dice[index]
       
dice = [1,2,3,4,5,6]
weights = [20, 12, 60, 58, 33, 10]  
sampled_value = proportional_sampling(dice, weights)

Experimentation

We will now run an experiment where will call the proportional_sampling 100 times and analyze the result of sampling a number

dice_result = {}
for i in range(0, 100):
    sampled_value = proportional_sampling(dice, weights)
    if sampled_value not in dice_result:
        dice_result[sampled_value] = 1
    else:
        dice_result[sampled_value] += 1

As you can see from the above figure the probability of getting a 3 is the highest since 3  was given a weight of 60 which was the largest number in the weights array. If we  run this experiment for 1000 iterations instead of 100 you can expect to get even more precise results.

The post Proportional Sampling Using Weighted Values appeared first on Be on the Right Side of Change.