Its classification problem predicts happy and sad images using CNN, Tensorflow 

Load these images off disk using the helpful 

tf.keras.utils.image_dataset_from_directory

Getting 305 files belonging to 2 classes(happy, sad).

Choose only ['jpeg', 'jpg', 'bmp', 'png'] extension images.

Dividing all the values by 255 will convert it to a range from 0 to 1.

20% of the data split for validation size

Design a convolutional neural network with 3 convolution layers and 1 fully connected layer to predict the happy & sad classes.

Use Adam as the optimizer, BinaryCrossentropy as the loss function, and accuracy as the evaluation metric.

Train the model using the epoch size of 20.

tensorboard_callback=tf.keras.callbacks.TensorBoard(log_dir=logdir)

hist = model.fit(train, epochs=20, validation_data=val, callbacks=[tensorboard_callback])

from tensorflow.keras.metrics import Precision, Recall, BinaryAccuracy

if yhat > 0.5:
print(f'Predicted class is Sad')
else:
print(f'Predicted class is Happy')

Classify Happy Sad Images

Household Electric Power Prediction from the UCI website, provided by Senior Researchers from France.

Measurements of electric power consumption in one household with a one-minute sampling rate over a period of almost 4 years. Different electrical quantities and some sub-metering values are available

Data from 47 months ranging from December 2006 to November 2010.

The Dataset has 9 attributes, out of which 3 are meter readings stating how much electricity unit appliances of various type has consumed.

df.drop(['Date','Time'], axis=1, inplace=True).

These columns have some special charecters(?) drop the special charecters 

df.drop(special_chr.index,axis= 0,inplace=True).

Checking the duplicated data. and remove it

['Sub_metering_1', 'Sub_metering_2', 'Sub_metering_3'] 

Voltage is approximately normally distributed.

Meter and Global_intensity are right-skewed.

Calculating the lower limit and upper limit of these columns and using 

 clause to replace columns lower than the lower limit which is lower limit otherwise if the columns have more than the upper limit then replace with the upper limit.

the input data set has large differences between their ranges, so to minimise the difference we need to standardize.

scaler = StandardScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.fit_transform(x_test)

["Linear Regression", "Ridge Regression", "Lasso Regression", "Support Vector Regression", "Decision Tree Regressor" and "Random Forest Regressor"]

 train and Predict each model and Calculating 

['Train Mean Squared Error ', 'Test Mean Squared Error', 'Train Mean Absolute Error', 'Test Mean Absolute Error', 'Train R Sqaure', 'Test R Sqaure', 'Train Adj R Sqaure', 'Test Adj R Sqaure' ] for every regression model.

Hyper-Parameter Tunning on RandomSearchCV:

n RandomizedSearchCV using 4 Parameters ["max_depth", "max_features", "min_samples_split", "n_estimators"].

After the Model Performance For Test Data

Before Hyper-parameter tunning Bagging accuracy.

Hyper-parameter tunning of bagging regressor:

RandomizedSearchCV using 3 Parameters ["max_depth", "max_features",  "n_estimators"].

bag_param = {
'n_estimators' : [50,100,200,500],
'max_samples' : range(2,5,1),
'max_features' : [2,3]
}

After the training and testing the Hyper-Parameter Tunning on Bagging Regressor" got the below accuracy.

Household Power Consumption

Classify Traffic Signs Using Deep Learning for Self-Driving Cars

We will train a Deep Convolutional Neural Network (CNN) to classify traffic sign images.

The dataset contains 43 different classes of images.

This project on Classify Traffic Sign Using Deep Learning for Self-Driving Cars is divided into following tasks:

Import Key python libraries, dataset and perform image visualization.

Perform image normalization and convert images from colour-scaled to gray-scaled.

Build a Convolutional Neural Network using Keras with Tensorflow 2.0 as a backend.

Compile and fit Deep Convolutional Neural Network model to training data.

Assess the performance of trained Convolutional Neural Network model and ensure its generalization using various KPIs.

Imported the necessary libraries for this project.

Task 4: Convert images to gray-scale and perform normalization

they are common in image processing because using a grayscale image requires less available space and is faster, especially when we deal with complex computations.

Use Relu and Softmax as the activation function.

Use Adam as the optimizer, sparse categorical cross-entropy as the loss function, and accuracy as the evaluation metric.

Task 7: Compile and train deep learning model

Observe the training and validation loss plots in Jupyter Notebook.

Using a heatmap to visualise a confusion matrix

Traffic Sign Classification

House Prices Prediction using Advanced Regression Techniques.

https://www.kaggle.com/c/house-prices-advanced-regression-techniques

Exploratory Data Analysis (EDA) is an approach to data analysis that employs a variety of techniques to

 Do a philosophical analysis about the meaning and importance of the variable for this problem

 Check Each Variable From the Statistical Point of View

 Understand how the dependent variable and independent variables relate

 Clean the dataset and handle the missing data, outliers and categorical variables

First, load the data and understand the data dimensions.

In this dataset, the sale price is the target variable. All others are features. Of the 79 variables, 36 are numerical and 43 are categorical.

Checking the target variable distribution:

BsmtFinSF2, LowQualFinSF, BsmtHalfBath, EnclosedPorch, ScreenPorch, PoolArea, and MiscVal has High Values as 0

MSSubClass, OverallQual, OverallCond, BsmtFullBath, BsmtHalfBath, FullBath, HalfBath, BedroomAbvGr, KitchenAbvGr, KitchenAbvGr, Fireplaces, GarageCars, PoolArea has very few unique values

MSSubClass, OverallQual can be converted to a categorical feature

Understand the trends and patterns of data

Analyze the frequency and other such characteristics of data

Know the distribution of the variables in the data.

Visualize the relationship that may exist between different variables.

The statistical study of data where multiple measurements are made on each experimental unit and where the relationships among multivariate measurements and their structure are important

These are the variables most correlated with 'SalePrice'.

'OverallQual', 'GrLivArea' strongly correlated with 'SalePrice'.

'GarageCars', 'GarageArea', 'TotalBsmtSF', '1stFlrSF' are also strongly correlated variables.

'TotRmsAbvGrd' and 'GrLivArea', also strongly correlated variables.

'YearBuilt' is slightly correlated with 'SalePrice'

'TotalBsmtSF' and 'GrLiveArea'. In this figure, we can see the dots drawing a linear line.

Basement areas can be equal to the above-ground living area, but it is not expected a basement area bigger than the above-ground living area

Missing values are basically records that don’t have a value associated with them. There are two common ways to treat this:

Fill the NaN values using statistical methods.

When more than 15% of the data is missing (e.g. 'PoolQC', 'MiscFeature', 'Alley', etc.) that should be deleted.

'MasVnrArea' and 'MasVnrType', these variables are not essential. Furthermore, they have a strong correlation with 'YearBuilt' and 'OverallQual' which are already considered. Thus, will be loose information if we delete 'MasVnrArea' and 'MasVnrType'.

Garages are expressed by 'GarageCars' and considering that we are just talking about 5% of missing data, I'll delete the mentioned 'Garage

An outlier is a value that is abnormally distant from the other values in a dataset. These can have a significant adverse effect on the analysis or predictions.

To standardise the data. that is far from the mean, finding lower ranges and high ranges and removing outliers.

Low-range values are similar and not too far from 0.

High-range values are far from 0 and the 7. something values are really out of range.

The two values with bigger 'GrLivArea' seem strange and they are not following the crowd.

these two points are not representative of the typical case. so delete them.

Exploratory Data Analysis

The dataset contains 10 features in which 'Price(in US dollars)' is a dependent feature. The goal is we have to predict the price of Diamonds using different Regression Algorithms.

https://www.kaggle.com/competitions/playground-series-s3e8/data?select=train.csv

There are 10 independent variables (including 

 : Carat (ct.) refers to the unique unit of weight measurement used exclusively to weigh gemstones and diamonds.

 : Diamond clarity is a measure of the purity and rarity of the stone, graded by the visibility of these characteristics under 10-power magnification.

 : The depth of the diamond is its height (in millimetres) measured from the culet (bottom tip) to the table (flat, top surface)

 : A diamond's table is the facet that can be seen when the stone is viewed face up.

This folder is used to store the pickle file(modal, preprocessor).

 This folder is used to store the iPython notebook (EDA, Modal Traning).

This is the main folder where all components and pipelines are implemented.

This file is used to store the logging info.

This folder is used for installing the necessary libraries.

Loading the data using an automated process, creating the DataIngestion class 

Splitting the data and storing the train.csv, test.csv, and raw.csv in the artefacts folder.

Check the distribution of the numerical_columns and categorical_columns.

Look at the correlation between the features before training a model

x, y and z show a strong correlation with the target column.

The depth, cut and table columns show a weak correlation.

Assign the rank of each categorical column respectively.

https://www.americangemsociety.org/ags-diamond-grading-system

Define the custom ranking for each ordinal variable

 for automated handling of the missing values using median and standardization.

 for converting the categorical values into numerical values

 for combining the numerical pipeline and categorical pipeline.

Splitting Dependent and Independent variables from train and test data.

=================================================

Diamond Price Prediction

Predict Whether the income of an individual exceeds $50K/year or not based on attributes given

https://www.kaggle.com/datasets/uciml/adult-census-income

Machine Learning Classification techniques are used in order to predict whether a person's yearly income falls in the income category of either greater than 50K Dollars or less than equal to 50K Dollars category based on a certain set of attributes.

The dataset contains 15 columns and 32561 rows. Which include ["age", "workclass", "fnlwgt", "education", "education.num", "marital.status", "occupation", "relationship", "race", "sex", "capital.gain", "capital.loss", "hours.per.week", "native.country", "income"].

An analysis of this kind helps to figure out which individual attributes are necessary for improving an individual's income so that focus can be put on those specific factors so as to level up the income of individuals.

Load the data and check the first five rows.

df['income'] = df['income'].map({"<=50K": 0,">50K":1}).

 These columns are containing a special symbol (?). Replacing these symbols using 

["occupation", "workclass", "native.country"] 

If the feature is a categorical feature then we have to use 

 to replaces NaN with forward & backward values.

Separate categorical and numerical features

['workclass', 'education', 'marital_status', 'occupation', 'relationship', 'race', 'sex', 'native_country'].

 ['age', 'fnlwgt', 'education_num', 'capital_gain', 'capital_loss', 'hours_per_week', 'income'].

Age is approximately normally distributed.

Final weight, capital loss & capital gain are heavily right-skewed.

Checking distribution and outliers together

If the data of the feature is continuous or discrete (numbers) then we don't have to do anything and we can directly standardize and train the model

But when the data is categorical (string) then we have to perform encoding, which means converting it to 0 or 1, then only we can train the model.

labelencoder_x = LabelEncoder()
x[categorical_fea] = [categorical_fea].apply(LabelEncoder().fit_transform)

Hyperparameter Tunning with GridSearchCV:

In GridSearchCV we are using only 5 parameters.

grid_param = {
'criterion':['gini','entropy'],
'max_depth': range(2,32,1),
'min_samples_leaf': range(1,10,1),
'min_samples_split': range(2,10,1),
'splitter':['best','random']
}

Hyperparameter Tunning with RandomizedSearchCV:

In RandomizedSearchCV using 4 Parameters ["max_depth", "max_features", "min_samples_split", "n_estimators"].

Adult Census Income

The data consists of 48x48 pixel grayscale images of faces. The faces have been automatically registered so that the face is more or less centered and occupies about the same amount of space in each image. The task is to categorize each face based on the emotion shown in the facial expression in to one of seven categories (0=Angry, 1=Disgust, 2=Fear, 3=Happy, 4=Sad, 5=Surprise, 6=Neutral).

This project on Facial Expression Recognition is divided into following tasks:

Develop a facial expression model in Keras

Build and train a convolutional neural network (CNN)

Deploy the trained model to a web interface with Flask

Apply the model to real-time video streams and image data

Display some images from every expression type in the Emotion FER 

Check for class imbalance problems in the training data.

Task 3: Generate Training and Validation Batches

Generate batches of tensor image data with real-time data augmentation.

Specify paths to training and validation image directories and generates batches of augmented data.

datagen_train = ImageDataGenerator(horizontal_flip=True) 

train_generator = datagen_train.flow_from_directory("train/", target_size= (img_size,img_size), color_mode="grayscale", batch_size=batch_size, class_mode='categorical', shuffle=True)

datagen_validation = ImageDataGenerator(horizontal_flip=True) 

validation_generator = datagen_validation.flow_from_directory("test/", target_size=(img_size,img_size), color_mode="grayscale", batch_size=batch_size, class_mode='categorical', shuffle=False)

Task 4: Create a Convolutional Neural Network (CNN) Model

Design a convolutional neural network with 4 convolution layers and 2 fully connected layers to predict 7 types of facial expressions.

Use Adam as the optimizer, categorical cross-entropy as the loss function, and accuracy as the evaluation metric.

 to save the weights associated with the higher validation accuracy.

Observe live training loss and accuracy plots in Jupyter Notebook for Keras.

Task 6: Save and Serialize Model as JSON String

Sometimes, you are only interested in the architecture of the model, and you don't need to save the weight values or the optimizer.

, which uses a JSON string, to store the model architecture.

Task 7: Create a Flask App to Serve Predictions

" to create a flask app to serve the model's prediction images directly to a web interface.

Task 8: Create a Class to Output Model Predictions

Create a FacialExpressionModel class to load the model from the JSON file, load the trained weights into the model, and predict facial expressions.

Task 9: Design an HTML Template for the Flask App

Design a basic template in HTML to create the layout for the Flask app.

Task 10: Use Model to Recognize Facial Expressions in Videos

 script to create the Flask app and serve the model's predictions to a web interface.

Facial Expression Recognition

Implement ridge regression using gradient descent and stochastic gradient descent.

https://bloomberg.github.io/foml/#assignment-homework-1

Let’s first understand ridge regression and stochastic gradient descent algorithm individually.

Ridge regression is linear regression with 𝑙2 regularization.

The regularization term is sometimes called a penalty term. The objective function for ridge regression is

where λ is the regularization parameter, which controls the degree of regularization. The bias parameter is being regularized as well.

Ridge Regression is a commonly used method of processing regression data with multicollinearity. When independent variables in a multiple regression model are correlated, we call it multicollinearity.

A gradient descent algorithm follows an iterative process that travels down the slope in steps, using local information, until reaching the lowest point.

There are three types of Gradient Descent :-

In SGD, instead of using the entire dataset for each iteration, only a single random training a small batch is selected to calculate the gradient and update the model parameters

 to normalize all the features to [0, 1].

Here i use one common approach to feature normalization is perform an affine transformation on each feature so that all feature values in the training set are in [0, 1].

Each feature gets its own transformation. Then I apply the same transformations to each feature on the test set.

The training set transformation is "learned", and then applied to the test set.

 it is a measure of the steepness of a slope. And sum up all the first-order derivatives of all the variables in a function, it gives us gradient.

 To optimize parameters, we need to minimize errors. The aim of the gradient descent algorithm is to reach the local minimum.

def batch_grad_descent(X, y,X_val, Y_val, alpha=0.1, num_iter=1000, check_gradient=False):

num_instances, num_features = X.shape[0], X.shape[1]
theta_hist = np.zeros((num_iter+1,1, num_features)) #Initialize theta_hist
loss_hist = np.zeros(num_iter+1) #initialize loss_hist
loss_hist_val = np.zeros(num_iter+1)
theta = np.zeros((1,num_features)) #initialize theta
for i in range(num_iter):
if check_gradient:
flag = generic_gradient_checker(X,y,theta_hist[i],compute_square_loss, compute_square_loss_gradient)
if not flag:
print('gradient check failed')
theta_hist[i] = theta
loss_hist[i] = compute_square_loss(X,y, theta_hist[i])
loss_hist_val[i] = compute_square_loss(X_val,Y_val, theta_hist[i])
tgrad = compute_square_loss_gradient(X,y,theta_hist[i])
theta = theta - alpha*tgrad
theta_hist[num_iter] = theta
loss_hist[num_iter] = compute_square_loss(X,y, theta_hist[num_iter])
loss_hist_val[num_iter] = compute_square_loss(X_val,Y_val, theta_hist[num_iter])

return theta_hist, loss_hist, loss_hist_val

1.4 Ridge Regression ( L2 regularization )

Computing the gradient of J(θ) and updating θ in the gradient descent algorithm.

Check out my Portfolio

Here's what I have done with the past