Dimensionality Reduction

The more fundamental part of ML is Mathematics, But if we take the list it goes on like algebra, statistics, calculus, geometry etc., and obviously we get confused. When we approach experts and ask, at this stage most of them will suggest us to go ahead with Linear Algebra.

But the problem will not stop there. we will get stuck up on the deep derivations and get confused again. So Now, we will have the overview of the topics in Linear Algebra and motivation behind it.

Why we Learn Linear Algebra?

When we are working with data, the first step is to and arrange our data in rows and columns format which looks like matrix where linear algebra comes into play.

For 2- dimensions, we call it as Matrix. For 1-dimension we call it as Vectors and for n-dimensions we call it as Tensors.

This matrix can be implemented via Numpy package which we discussed in previous blog. Before we look into that, let us take a quick look on the reasons to NOT to learn linear Algebra:

1. Learning Linear Algebra will take months to years to study the entire field. This will delay in achieving goal to work on Real Time ML problems.

2. Since Not all topics in Linear algebra is relevant to theoretical Machine learning but also the applied ML.

Implementing Matrices in Python

A 2-dimensional Numpy array is used to represent matrix in python. A numpy array with lists of list gives us matrix. An example with 2X3 matrix as below.

Matrix – Matrix Multiplication

The matrix multiplication is also called as matrix DOT product which is more complicated than the previous operations.

Basic rule for this Dot product is that, the number of columns in the First matrix must equal to the number of rows in second matrix.

If A is of shape M x N and B is of shape N x P then C is of shape M x P.

#identity Matrix
from numpy import identity
I = identity(3)
print(I)

Have fun by making changes to the above code and do let me know if you found something interesting 🙂

As the name suggests, once we are provided with real time data we should understand the data first and then we should able to get some insights from the provided data.

These insights can be gained only by analyzing and exploring the provided data, which we would call as Exploratory data analysis or EDA Process.

The data analysis can be done by our basic python libraries Numpy, Pandas, Matplotlib, etc., Good knowledge on our data will help us to get the answers that we need or develop an intuition for interpreting the results of future modeling.

There are a lot of ways to reach these goals: we can get a basic description of the data, visualize it, identify patterns in it, identify challenges of using the data, etc.

Direct definition: The Basic definition of EDA is, Exploratory data analysis is an approach to analyzing data sets by summarizing their main characteristics with visualizations. The EDA process is a crucial step prior to building a model in order to unravel various insights that later become important in developing a robust algorithmic model.

Now, we will go through a basic analysis step, when we are ready with real time data.

1. Choosing a Dataset: First, rely on open source data to initiate ML execution. There are mountains of data for machine learning around and some companies (like Google) are ready to give it away. we have many open sources like UCI Repository, Data.gov, Kaggle etc., From here we can choose our dataset base on our interests

2. Exploring the Dataset: The critical step in EDA process, is that understanding the data better by using different python libraries and checking the relationship between data.

3. Data Visualization: This step makes use of the plot library like matplotlib etc., in order to portray our understandings in picture model. This will help us to get more insights on data.

4. The Final step: This step is where our ML algorithms comes into play to provide insights on future unseen data.

As we have some basic understanding of python libraries now. we will gonna have fun with real time data in next blog.

Let’s wait to dirty your hands. have a great day:) Bye

Scikit-Learn is a basic standard to work with machine learning in python. It provides a python libraries for solid implementation of machine-learning algorithms. Scikit-learn provides a wide selection of supervised and unsupervised learning algorithms. Best of all, it’s by far the easiest and cleanest ML library.

Scikit Learn is built on top of several common data and math Python libraries. Such a design makes it super easy to integrate between them all. You can pass numpy arrays and pandas data frames directly to the ML algoirthms of Scikit! It uses the following libraries:

• NumPy: For any work with matrices, especially math operations
• SciPy: Scientific and technical computing
• Matplotlib: Data visualisation
• IPython: Interactive console for Python
• Sympy: Symbolic mathematics
• Pandas: Data handling, manipulation, and analysis

Scikit’s robust set of algorithm offerings includes:

• Regression: Fitting linear and non-linear models
• Clustering: Unsupervised classification
• Decision Trees: Tree induction and pruning for both classification and regression tasks
• Neural Networks: End-to-end training for both classification and regression. Layers can be easily defined in a tuple
• SVMs: for learning decision boundaries
• Naive Bayes: Direct probabilistic modelling

Even beyond that, it has some very convenient and advanced functions not commonly offered by other libraries:

• Ensemble Methods: Boosting, Bagging, Random Forest, Model voting and averaging
• Feature Manipulation: Dimensionality reduction, feature selection, feature analysis
• Outlier Detection: For detecting outliers and rejecting noise
• Model selection and validation: Cross-validation, Hyperparamter tuning, and metrics

Documentation

I recommend starting out with the quick-start tutorial and flicking through the user guide and example gallery for algorithms that interest you.

Ultimately, scikit-learn is a library and the API reference will be the best documentation for getting things done.

• Quick Start Tutorial http://scikit-learn.org/stable/tutorial/basic/tutorial.html
• User Guide http://scikit-learn.org/stable/user_guide.html
• API Reference http://scikit-learn.org/stable/modules/classes.html
• Example Gallery http://scikit-learn.org/stable/auto_examples/index.html

Papers

If you interested in more information about how the project started and it’s vision, there are some papers you may want to check-out.

• Scikit-learn: Machine Learning in Python (2011)
• API design for machine learning software: experiences from the scikit-learn project (2013)

Books

If you are looking for a good book, I recommend “Building Machine Learning Systems with Python”. It’s well written and the examples are interesting.

• Learning scikit-learn: Machine Learning in Python (2013)
• Building Machine Learning Systems with Python (2013)
• Statistics, Data Mining, and Machine Learning in Astronomy: A Practical Python Guide for the Analysis of Survey Data (2014)

There is an old sayings, “One picture can tell thousand words“. Its true in case of matplotlib library in python. This python library can visualize our work in 2-dimensional spaces.

Matplotlib is a plotting library for the Python programming language and its numerical mathematics extension NumPy. One of the greatest benefits of visualization is that it allows us visual access to huge amounts of data in easily digestible visuals. Matplotlib consists of several plots like line, bar, scatter, histogram etc.

Importing matplotlib :

from matplotlib import pyplot as plt
or
import matplotlib.pyplot as plt 

Basic plots in Matplotlib :

Matplotlib comes with a wide variety of plots. Plots helps to understand trends, patterns, and to make correlations. They’re typically instruments for reasoning about quantitative information. Some of the sample plots are covered here.

#importing matplotlib module
from matplotlib import pyplot as plt  

#x-axis values
x=[5,3,7,2,1]

#y-axis values
y=[10,5,2,9,2]

plt.plot(x,y)

#Function to show the plot
plt.show()

For Bar plots, we can use plt.bar(x,y)

For Histogram, we can use plt.hist(x,y)

For scatter plots, we can use plt.scatter(x,y)

Do try the above codes and have fun 🙂

Hope you enjoyed my blog. Bye and Take care:)

Pandas consists of two basic data structure called Series and Dataframe.

Pandas is also one of the most important python library for data manipulation and analysis.

Like Numpy package, we install pandas package by the command “pip install python” in python prompt. Now the installed package can be utilized by the import command, “import pandas as pd “, pd is the variable to access the properties of the package for our data.

Series:

Series is a one-dimensional labeled array capable of holding any data type (integers, strings, floating point numbers, Python objects, etc.). The axis labels are collectively referred to as the index. The basic method to create a Series is to call:

s = pd.Series(data)

Now, we will jump into the basic operations on pandas series in python.

Creating a Pandas Series – In order to create a series from array, we have to import a numpy module and have to use array() function. Check my Numpy Basics blog to know more about numpy arrays.

import pandas as pd
import numpy as np

#Simple Array
data = np.array(['g', 'e', 'e','k','s'])

#Converting numpy array into series object and storing the variable
series = pd.Series(data) 

In the above operation, we created series using numpy array, Likewise we are going to create a series using python lists.

# a simple list
 list=['g', 'e', 'e', 'k', 's']

# create series form a list
 series =pd.Series(list)
 print(series) 

Accessing Elements from Series:

The Series element can be accessed by position as well as by index.

# creating simple array
 data = np.array(['g','e','e','k','s','f','o','r','g','e','e','k','s'])
 series = pd.Series(data)

# Retrieving the first 5 elements
 print(series[:5]) 

Let’s check on some binary operations on series:

 # importing pandas module 
 import pandas as pd 

 # creating a series and assigned to a variable data
 data =pd.Series([5, 2, 3,7], index=['a', 'b', 'c', 'd'])

 # creating a series and assigned to a variable data1
 data1 =pd.Series([1, 6, 4, 9], index=['a', 'b', 'd', 'e'])
 print(data, "\n\n", data1)

 # adding two series using  .add
 data.add(data1)

 # subtracting two series using .sub
 data.sub(data1) 

mul() – Method is used to multiply series or list like objects with same length with the caller series.

div() – Method is used to divide series or list like objects with same length by the caller series.

sum() – Returns the sum of the values for the requested axis.

prod() – Returns the product of the values for the requested axis.

mean() – Returns the mean of the values for the requested axis

pow() – Method is used to put each element of passed series as exponential power of caller series and returned the results.

abs() – Method is used to get the absolute numeric value of each element in Series/DataFrame.

cov() – Method is used to find covariance of two series.

DataFrame:

Pandas Data Frame consists of main components, the data, rows, and columns.

The pandas data frame can be created by loading the data from the external, existing storage like a database, SQL or CSV files.

But the pandas Data Frame can also be created from the lists, dictionary, etc.

One of the ways to create a pandas data frame is shown below:

 #import the pandas library
 import pandas as pd

 # Dictionary of key pair values called data 
 data = {'Name':['Ashika', 'Tanu', 'Ashwin', 'Mohit', 'Sourabh'],         'Age': [24, 23, 22, 19, 10]}

 #Output
 data{'Age': [24, 23, 22, 19, 10],  'Name': ['Ashika', 'Tanu', 'Ashwin', 'Mohit', 'Sourabh']}

 # Calling the pandas data frame method by passing the dictionary (data) as            a parameter 
 df = pd.DataFrame(data) 
 df 

Performing on Rows and Columns:

Selecting a Column: In order to select a particular column, all we can do is just call the name of the column inside the data frame.

# Calling the pandas data frame method by passing the dictionary (data) as a parameter 
df = pd.DataFrame(data)

# Selecting column 
df[['Name']]  

Selecting Row: Pandas Data Frame provides a method called “loc” which is used to retrieve rows from the data frame. Also, rows can also be selected by using the “iloc” as a function.

# Calling the pandas data frame method by passing the dictionary (data) as a parameter
  
df = pd.DataFrame(data) 
 
# Selecting a row 
row = df.loc[1] 
row 

 #output
 Name    Tanu  Age       23  Name: 1, dtype: object 

The loc method accepts only integers as a parameter.

Working with Missing Data :

Missing data occurs a lot of times when we are accessing big data sets. It occurs often like NaN (Not a number). In order to fill those values, we can use “isnull()” method. This method checks whether a null value is present in a data frame or not.

# importing both pandas and numpy libraries 
 import pandas as pd 
 import numpy as np
 # Dictionary of key pair values called data
 data ={‘First name’:[‘Tanu’, np.nan], ‘Age’: [23, np.nan]}
 df = pd.DataFrame(data)
 df 

# using the isnull() function

df.isnull()

The isnull() returns false if the null is not present and true for null values.

Now we have found the missing values, the next task is to fill those values with 0 this can be done as shown below:

df.fillna(0)

Now the null values, will be assigned as 0 in the column values.

Now we have reached the end of our blog, Hope you enjoyed reading my blog!

Take care and do comment below 🙂

We are here to explore one of the basic package in python called Numpy. Without any mathematical computations, we could not infer any insights from the data, Hence we use Numpy package for the same.

As we can arrange our data into one-Dimensional, two-dimensional and so on. The 1D data are Vectors, 2D are Matrices and ND are as Tensors.

Here we will perform some operations on these 1D, 2D and nD form of data. These data can be stored in an data structure called array in different dimensions as said above. A high – level mathematical functions are written in this library, which can support the following:

• Powerful N-dimensional array object.
• Broadcasting functions.
• Tools for integrating C/C++ and Fortran code.
• Useful for computing linear algebra, Fourier transform, and random number capabilities.

Now, we will install numpy package using the command, “”pip install numpy“” which will install the numpy package successfully.

In order to use this package to our data, we need to import using the command

“import numpy as np“, np is an variable which will be used everywhere to access numpy package.

Creating Numpy Arrays

Here the numpy arrays are created using the variable np. Since it is an 2-Dim array, we created using 2 square brackets. [[]]

The type function, tells us the type of the array, whereas the shape function provide us the no.of rows and no.of columns in the array. The dtype gives us the datatype of the array values.

Now, we will explore some basic methods in numpy arrays which can be used for our analysis on the real world data.

arange() – arange method can be used to create array values, with the following 4 parameters.

The syntax of the method is

np.arange(start=None, stop=None, step=None, dtype=None)

start = 0 stop = 10 step = 3

If you are not giving step value by default it will take value 1.

linspace() – Creates any size of the evenly spaced array or matrices between specified interval.

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

np.linspace ( ) has 6 parameters :

• start — Starting value of the sequence
• stop — Last value of the sequence
• num — Number of samples to be generated
• endpoint — This is a boolean value. If the value of endpoint is true, then stop is the last sample of the sequence. The default value of endpoint is true.
• retstep — Default value is true. If the value of retstep is true then return samples and steps(the difference between 2 samples)
• dtype — The type of array or matrices

np.linspace(5., 10., 3)
array([5., 7.5, 10])
============================
start = 5.
stop = 10.
num = 3

reshape() – The main function of the numpy library is reshape() which is used to convert 1D array to nd matrices.

The important point to remember is that the multiplication of parameters equals to the no. of elements in the 1-Dimensional array.

np.arange(0, 10, 3) array([0, 3, 6, 9]) =================== Total numbers of array elements = 4

=========================================== np.arange(0, 10, 3).reshape(2, 2) array([[0, 3],[6, 9]]) ====================== Multiplication of reshape parameters = 4[2*2] ============================================

Total numbers of array element is equal to Multiplication of reshape parameters

zeros() – This method gives 0 values to the sample in the matrix.

 
np.zeros((2,3))
 array([[0.,0.,0.,],
           [0.,0.,0.,]])

ones() – np.ones( ) gives the 1 value to each sample in the matrix.

full() – It gives the constant samples to the matrix.

eye( ) – This method gives the identical matrix as a result. In the below example, it gives 2-Dimensional identical matrices.

random() – np.random( ) gives the random samples. The below example gives 2-Dimensional matrix of 2*3(number of rows = 2 and number of columns = 3) with random values.

We have reached the end of our blog, Hope you enjoyed reading my blog!.

Let’s explore pandas basics in the next blog. Comments are welcome 🙂

Data Structures are the simple structures to hold our data. These structures are helpful in performing some operations on our data like storing, managing, accessing etc.,

The basic data structure of the python includes the List ,Tuples , Sets and Dictionaries.

Python Lists :

Python lists will hold data inside the square brackets [] and are arranged in a sequential manner separated by comma. The List can store different types of values including lists by itself.

The Lists are MUTABLE, means the values can be changed after assigning the values to it.

We will check some operations on the Lists below:

In order to store data into the List structure, we need to declare the list first and we can able to do many operations on the lists datastructure.

Declaring a Lists:

# Declaring a variable my_list and storing different data into it my_List = [L1,L2,03,[53]]

Accessing a Lists:

A lists can be accessed by positive indexing as well as negative Indexing. The lists stores the value starting with zero,one and so on.

my_List[3] # will print [53], accessing the 4th value(53) in the list

The following are the methods to perform some operations on the list values.

1. Finding the length of the list – len()

2. List Append – Appending will add a value at the end of the list

3. List Extend – Extend also adds value at the end, but there is small difference when we try to add list values.

4. List Insert – Inserts the value at the specified index, as the insert method takes two parameters. One is the location another is an value to insert.

5. List Remove – Like the other methods, we use remove() method to remove the value from list , and we can use pop() method to do the same.

6. List Sorting – In list we can use the sorted() method to sort the elements of the list.

7. List Reverse – This will return the elements of the list in reverse order.

8. List Looping – we will now loop the elements in the list, using for loop and in operator.

9. List Slicing – Segmenting a part of the list is known as Slicing, The slicing operation can be performed by indexing.

TEST YOURSELF:

Q1) What is the difference between delete, remove and pop methods in python lists?

Use the methods and explore the difference in the methods by yourself and have fun 🙂

Python Tuples :

Tuples operate in the same way as Lists, the only difference is that the tuple elements are enclosed in the paranthesis() and Immutable (Elements cannot be changed once it is assigned).

Let’s see an example for immutable property of the tuple.

TEST YOURSELF:

Q2) How come satish replaces value of 6 in the tuple? Do check and comment below, awaiting for your answers 🙂

Q3) From the above example, we could see the type of t is str, what we have to actually do to get type as “Tuple”? Do check and comment below 🙂

Python Sets:

Till now, we checked the sequential data structures [Lists and Tuples] in python. The sets in python are the unordered collection of unique items as there will not be any duplicates.

The set is Mutable and are enclosed in the curly braces {}.

The following are the creation of set in python.

We add elements to the set by add() method and using update() method. Sets will not support indexing operation in python

As the name suggests, we can perform mathematical operations on sets like Union, Intersection, Difference etc.., Why don’t you try and perform some operations 🙂

The elements from the sets are remove using remove(), discard(), delete(),pop() methods.

Special Type of Set : Frozen Sets

A special type of set called frozenset can be used, in which the elements in the frozenset are immutable same as in the python tuples.

Being immutable, it does not support add() method.

Python Dictionary:

The python dictionary is an unordered collection of items, which contains not only values also the key and value pair.

The following are the methods for the dictionary creation.

Accessing the Dict Values:

We can access the dict values by using keys or the get method. The only difference is that, Using get() method will return None if the key is not present in the dictionary otherwise it returns an key error.

The following are the methods in the python dictionary.

Can u guess the output for values() method?

Hope you enjoy reading my blog, looking forward for your answers and comments below

Bye and Take care, Let’s meet in the next blog:)