Below are the project categories that I have worked on. You can find the project descriptions and respective Github links of the projects in the dropdown description of each project on this page.
Below are the project categories that I have worked on. You can find the project descriptions and respective Github links of the projects in the dropdown description of each project on this page.
In this section, I present four projects that I worked on during my data mining course. These projects cover various topics and techniques of data mining, such as data preprocessing, visualization, exploratory data analysis, classification, association analysis, and clustering.
Project 1: Data Preprocessing, Visualization and EDA. In this project, I used Python and R to perform data preprocessing, visualization and exploratory data analysis on different types of datasets, such as census data, movie ratings, and stock prices. I applied various methods and tools to clean, transform, summarize, and explore the data, such as pandas, numpy, matplotlib, seaborn, ggplot2, and dplyr.
Project 2: Classification using Decision Trees and KNN. In this project, I used Python to implement and compare two classification algorithms: decision trees and k-nearest neighbors (KNN). I applied these algorithms to classify different types of data, such as iris flowers, breast cancer tumors, and credit card fraud. I evaluated the performance and accuracy of the algorithms using various metrics and visualizations, such as confusion matrix, accuracy score, precision score, recall score, f1 score, ROC curve, and AUC score.
Project 3: Association Analysis using Apriori Probabilities. In this project, I used Python to implement and apply the apriori algorithm for association analysis. The apriori algorithm is a method for finding frequent itemsets and association rules in transactional data. I applied the algorithm to find the frequent itemsets and association rules in different types of datasets, such as supermarket transactions, movie ratings, and book purchases. I used various parameters and measures to filter and rank the results, such as minimum support, minimum confidence, minimum lift, and leverage.
Project 4: Clustering Techniques using Python. In this project, I used Python to implement and compare two clustering techniques: k-means clustering and hierarchical clustering. Clustering is a method for finding groups of similar objects in unlabeled data. I applied these techniques to cluster different types of data, such as iris flowers, wine quality, and customer segmentation. I used various methods and tools to perform clustering and evaluate the results, such as scikit-learn, scipy.cluster.hierarchy , dendrogram , silhouette score , and elbow method .
In this project, I constructed and compared three machine learning models to predict the possibility of Parkinson’s disease based on various features such as voice measurements, age, gender, etc. The models are implemented using Scikit-learn framework and the data is obtained from the Kaggle data set.
The three models are: a regression model, a naive Bayes model, and a decision tree model. The regression model uses a linear function to estimate the probability of Parkinson’s disease. The naive Bayes model uses a probabilistic approach based on Bayes’ theorem to calculate the posterior probability of Parkinson’s disease. The decision tree model uses a tree-like structure to split the data into different branches based on certain criteria and assign a class label to each leaf node.
I trained and evaluated the models using a K-fold cross-validation technique to split the data into different folds and use one fold as the test set and the rest as the training set. I repeated this process for each fold and calculated the average accuracy of each model. The results show that the decision tree model has the highest accuracy of 98.31%, followed by the naive Bayes model with 88.24%, and the regression model with 84.71%. The project demonstrates the skills and knowledge of machine learning and data analysis using Scikit-learn.
In this project, I developed a neural network model that can answer natural language questions about the number of objects in an image. For example, given an image of a street scene and a question like “How many cars are there?”, the model can generate an answer like “Four”. This task is known as Visual Question Answering (VQA) and it requires the integration of computer vision and natural language processing techniques.
To build the model, I used TensorFlow and Keras frameworks and implemented two main components: a Convolutional Neural Network (CNN) and a Long Short-Term Memory (LSTM) network. The CNN is used to extract features from the image data, while the LSTM is used to encode the question and generate the answer. Additionally, I used attention mechanisms to allow the model to focus on relevant regions of the image and words of the question.
I trained and evaluated the model on a large-scale data set consisting of images from the MS COCO data set and corresponding questions and answers from the VQA v2 data set. The data set contains over 200,000 images and 1.1 million question-answer pairs. The questions are categorized into different types, such as yes/no, number, color, etc. I focused on the number type questions, which account for about 10% of the data set.
The results show that the model can achieve an accuracy of 88.87% on the number type questions, which is comparable to some of the state-of-the-art models in the literature. The model can also handle various types of counting questions, such as counting objects of different categories, sizes, colors, etc. The project demonstrates the feasibility and potential of using neural network models for VQA tasks.
In this project, I developed a neural network model that can generate natural language captions for images. The model uses a Long Short-Term Memory (LSTM) network as a language generator and conditions it on the image features. The model is implemented using TensorFlow framework.
The model consists of two main components: an encoder and a decoder. The encoder is a Convolutional Neural Network (CNN) that extracts features from the image data. The decoder is an LSTM network that takes the image features as input and generates a sequence of words as output. The decoder uses an attention mechanism to focus on relevant regions of the image while generating the caption.
I trained and evaluated the model on a large-scale data set consisting of images and captions from the Flickr8k data set. The data set contains about 25,000 images and 125,000 captions. I also implemented two different decoder functions for language generation: a greedy search and a beam search. I modified the decoder functions to generate captions in the context of images by using the image features as an additional input.
The results show that the model can generate coherent and descriptive captions for images with different scenes and objects. The model can also handle various types of captions, such as descriptive, informative, humorous, etc. The project demonstrates the skills and knowledge of image processing and natural language generation using TensorFlow.
In this section, I present four projects that I worked on during my machine learning course. These projects cover various topics and applications of machine learning, such as classification, dimensionality reduction, natural language processing, and computer vision.
Project 1: Classification on Simple Datasets. In this project, I applied basic machine learning models such as KNN, SVC, and logistic regression to classify different types of data, such as iris flowers, breast cancer tumors, and handwritten digits. I compared the performance and accuracy of the models using various metrics and visualizations.
Project 2: Face Classification using PCA and ICA. In this project, I used principal component analysis (PCA) and independent component analysis (ICA) to reduce the dimensionality of face images and extract the most significant features. I then used these features to classify the faces into different categories, such as gender, expression, and identity.
Project 3: Image Captioning using Conditioned LSTM Generators. In this project, I implemented a neural network model that can generate natural language captions for images. The model uses a convolutional neural network (CNN) to extract features from the image data and a long short-term memory (LSTM) network to encode the question and generate the answer. The model also uses attention mechanisms to focus on relevant regions of the image and words of the question.
Project 4: Visual Question Answering (VQA). In this project, I implemented a neural network model that can answer natural language questions about the content of an image. The model uses a CNN to extract features from the image data and an LSTM network to encode the question and generate the answer. The model also uses attention mechanisms to focus on relevant regions of the image and words of the question.
This project implements two state space search algorithms on a given graph: uninformed search (UCS) and informed search (A star). The graph is represented by an input text file that specifies the nodes and edges with their costs. The informed search also uses a heuristic text file that provides the estimated cost from each node to the goal. The user can choose which mode to run and whether to print the fringe and closed list after each node expansion. The output is either the optimal path from the source to the destination node or a message indicating that no such path exists. The code is written in Python and can be executed as follows:
python find_route.py input_textfile source destination [heuristics_textfile]
where [heuristics_textfile] is optional and only needed for informed search.
This project implements the minimax algorithm with alpha-beta pruning to play the game of maxconnect4. The game is a variation of connect four where the goal is to maximize the number of four-in-a-rows on the board. The code is written in Python and can be executed as follows:
python maxconnect4.py interactive [input_file] [computer-next/human-next] [depth]
or
python maxconnect4.py one-move [input_file] [output_file] [depth]
where [input_file] and [output_file] are text files that represent the board state, [computer-next/human-next] indicates who plays next in interactive mode, and [depth] is the depth limit for the minimax search.
The code uses a custom evaluation function that assigns scores to different board configurations based on how favorable they are for the current player. The evaluation function uses a set of masks to check for potential four-in-a-rows and also considers the difference between the player’s score and the opponent’s score. The code also prints the name of the current player in interactive mode.
In this project, I implemented a Rubik’s cube solver program using Python. The program can generate a sequence of moves to solve a 3x3 Rubik’s cube from any scrambled state using the beginner’s method. The beginner’s method is a simple and intuitive method that involves solving the cube layer by layer.
The program consists of two main files: main.py and solve_cube.py. The main.py file contains the main function that allows the user to enter the colors of each face of the cube. The colors are represented by letters: W for white, R for red, G for green, B for blue, O for orange, and Y for yellow. The user can enter the colors in a clockwise order starting from the top-left corner of each face. The program then calls the functions from solve_cube.py to find the moves that should be performed.
The solve_cube.py file contains the functions that implement the beginner’s method. The functions are divided into four steps: solving the white cross, solving the white corners, solving the middle layer, and solving the yellow face. Each function returns a list of moves that are required to complete the step. The moves are represented by letters and numbers: F for front face, R for right face, U for upper face, L for left face, D for down face, B for back face, and 1 for clockwise rotation, 2 for 180 degrees rotation, and -1 for counter-clockwise rotation. For example, F1 means rotating the front face clockwise by 90 degrees.
The program also uses a helper file called get_position.py that provides some utility functions to solve_cube.py. These functions include finding the position and orientation of a specific piece on the cube, finding the adjacent pieces on a face, and checking if a face or a layer is solved.
The program displays the moves and the state of the cube after each move on the command prompt window. The state of the cube is shown as a 2D array of letters representing the colors. The program also checks if the cube is solved at the end.
The project demonstrates the skills and knowledge of Python programming and algorithm design using recursion and loops. The project also shows how to use modular programming and abstraction to organize code into different files and functions.
In this project, I implemented a face detection technique using the Eigenface algorithm, which is an appearance-based approach to face recognition that uses principal component analysis to capture the variation in a collection of face images. The project is implemented using Python and Jupyter Notebook.
The project consists of two main parts: creating an Eigenface matrix and performing face detection. The Eigenface matrix is a set of eigenvectors that represent the most significant features of the face images. The Eigenface matrix is computed by applying principal component analysis to a dataset of face images and selecting the eigenvectors with the highest eigenvalues. The project uses the Yale Face Database as the dataset of face images.
The face detection part involves encoding and comparing images of individual faces in a holistic manner using the Eigenface matrix. The encoding process transforms a face image into a low-dimensional vector of weights by projecting it onto the Eigenface matrix. The comparison process measures the similarity between two face images by computing the Euclidean distance between their weight vectors. The project uses OpenCV library to perform image processing and display operations.
The project demonstrates the skills and knowledge of face recognition and Python programming using the Eigenface algorithm.
In this project, I implemented two image processing techniques using Python: Hough transform and Harris corner detection. The Hough transform is a method for finding straight lines in an image by transforming the image coordinates into a parameter space and finding the peaks in the accumulator matrix. The Harris corner detection is a method for finding corners in an image by computing the eigenvalues of the second moment matrix and applying a threshold to the corner response function.
The code consists of two main parts: a Hough transform function and a Harris corner detection function. The Hough transform function takes an input image and returns a list of lines detected in the image. The function uses OpenCV library to perform edge detection, thresholding, and Hough transform operations. The Harris corner detection function takes an input image and returns a list of corners detected in the image. The function uses NumPy library to perform gradient computation, convolution, eigenvalue calculation, and non-maximum suppression operations.
The code is tested on various images and the results are displayed using Matplotlib library. The results show that the code can successfully detect lines and corners in different types of images, such as buildings, chessboards, shapes, etc. The project demonstrates the skills and knowledge of image processing and Python programming.
In this project, I implemented a method for image stitching, which is the process of combining multiple images with overlapping regions into a single panoramic image. The method involves four main steps:
Step 1: Detecting keypoints and extracting local invariant descriptors from two input images. Keypoints are salient points in an image that can be used to describe its features. Descriptors are vectors that represent the local appearance of the keypoints. I used SIFT algorithm to detect and extract keypoints and descriptors from the images.
Step 2: Matching the descriptors between the images. This step involves finding the correspondences between the keypoints in the two images based on their descriptors. I used FLANN matcher to perform an approximate nearest neighbor search and find the best matches for each descriptor.
Step 3: Estimating a homography matrix using our matched feature vectors. A homography matrix is a transformation matrix that relates the coordinates of the keypoints in one image to the coordinates of the corresponding keypoints in the other image. I used RANSAC algorithm to estimate a robust homography matrix from our matched feature vectors.
Step 4: Applying a warping transformation using the homography matrix obtained from Step 3. This step involves transforming one of the images to align it with the other image using the homography matrix. I used OpenCV library to perform the warping transformation and obtain a stitched image.
The project demonstrates the skills and knowledge of computer vision and image processing using Python and OpenCV.
In this project, I designed and developed a device and an app that can help humans recall the location of objects that they have misplaced or forgotten. The device uses object detection techniques to identify and track the objects that the user interacts with and stores information such as time, date, and last seen location. The app provides three ways for the user to access the information and retrieve the objects: a graphical interface, a voice assistant, and a virtual reality mode.
The device is a wearable camera that can be attached to the user’s clothing or accessories. The device uses OpenCV library to detect and recognize the objects that the user picks up or puts down. The device also uses GPS and Wi-Fi modules to record the location of the objects. The device communicates with the app via Bluetooth.
The app is developed using Kivy framework for cross-platform compatibility. The app has three modes of operation: a graphical interface, a voice assistant, and a virtual reality mode. The graphical interface shows a list of objects that the user has interacted with and their corresponding information. The user can tap on an object to see its location on a map or a floor plan. The voice assistant allows the user to ask questions about the objects using natural language and get answers from the app. The virtual reality mode uses an Android app and Google VR cardboard to create a 3D environment where the user can see the objects in their original locations.
The project demonstrates the skills and knowledge of object detection, app development, and artificial intelligence using Python 3.
In this project, I developed a database system for a music business that allows customers to buy or rent songs online. The system consists of a backend using Oracle SQL and a frontend using Python.
The backend involves designing and implementing a database structure that can store and manage information about songs, artists, albums, genres, customers, orders, payments, etc. To design the database, I applied various modeling techniques such as EER diagrams, normalization, and relational mapping to ensure data integrity and consistency. I also created 19 tables with appropriate constraints and indexes to improve query efficiency and reduce database size.
The front end involves developing a user interface using Python that can interact with the database and perform various operations such as browsing, searching, buying, renting, rating, and reviewing songs. The interface also provides features such as user authentication, shopping cart, payment processing, and order history.
To test and evaluate the system, I executed 10 complex queries using SQL clauses such as ROLLUP, CUBE, OVER, etc. to analyze data in the tables and generate reports. The queries helped me gain new strategic insights into the business performance and customer behavior. The project demonstrates the skills and knowledge of database design and development using Oracle SQL and Python.
This project implements and compares two buffer replacement policies for managing the buffer pool in a database system: Least Recently Used (LRU) and Most Recently Used (MRU). The buffer pool is a memory area that stores the pages that are accessed by the database operations. The buffer replacement policy decides which page to evict from the buffer pool when it is full and a new page needs to be loaded. The project tests the performance of the LRU and MRU policies for two different buffer sizes: 15 and 45 pages. The project also calculates and displays the buffer hit ratio (BHR) and other statistics such as the number of page hits, page loads and page faults for each policy and buffer size.
In this project, I implemented a multi-threaded transaction management system that can execute concurrent transactions on a shared database using strict two-phase locking protocol. The system is developed using C/C++ and uses semaphores and threads to synchronize and coordinate the transactions.
The system consists of two main components: a Transaction Manager and a Transactions class. The Transaction Manager is responsible for managing the locks on the database items and granting or denying requests from the transactions. The Transactions class represents the transactions that are executed by different threads and perform read or write operations on the database items.
To implement the strict two-phase locking protocol, I ensured that each transaction follows two phases: a growing phase and a shrinking phase. In the growing phase, the transaction can acquire locks but cannot release them. In the shrinking phase, the transaction can release locks but cannot acquire new ones. This protocol ensures serializability and prevents deadlocks.
To test and evaluate the system, I ran various scenarios with different numbers and types of transactions and measured the accuracy and performance of the system. The results show that the system can achieve 95% accuracy in transaction execution and eliminate race conditions. The project demonstrates the skills and knowledge of concurrency control and transaction management using C/C++.
This project explores the use of MapReduce programming model for data analysis on a large-scale dataset. The project consists of two parts: a programming exercise and an analysis report. The programming exercise involves implementing three MapReduce programs using Hadoop framework to perform different tasks on IMDB dataset.
In this project, I implemented a calculator for evaluating expressions in reverse polish notation (RPN), which is a postfix notation where the operators follow the operands. The project is implemented using Python and consists of two parts: evaluating RPN expressions and converting infix expressions to RPN.
The first part involves creating a function that takes an RPN expression as a string and returns its numerical value. The function uses a stack data structure to store the operands and performs the operations according to the order of the operators. The function can handle basic arithmetic operators such as +, -, *, /, as well as parentheses and negative numbers.
The second part involves creating a function that takes an infix expression as a string and converts it to an RPN expression. The function uses another stack data structure to store the operators and follows the precedence and associativity rules of the infix notation. The function can handle the same operators as the first part, as well as exponentiation (^).
The project demonstrates the skills and knowledge of data structures, algorithms, and Python programming using the RPN notation.
In this project, I implemented a maze generator program using Python. The program is based on a classic example of spaghetti code written in BASIC language, which uses a lot of GOTO statements to create random mazes. The program prints the mazes as ASCII characters on the screen.
The main challenge of the project was to convert the GOTO functionality to Python function calls, as Python does not support GOTO statements. To achieve this, I used a function called “visit”, which is a sub-function of the main function “generate_maze”. The visit function takes the coordinates of a cell in the maze and marks it as visited. Then, it randomly chooses one of the four directions (north, south, east, west) and checks if the adjacent cell in that direction is unvisited. If so, it breaks the wall between the two cells and calls itself recursively on the adjacent cell. Otherwise, it chooses another direction until all directions are exhausted.
The project demonstrates the skills and knowledge of Python programming and algorithm design using recursion. The project also shows how to refactor spaghetti code into more structured and readable code.
In this project, I demonstrated a prototype of a cradle that can automatically swing on detecting a baby cry. The cradle also has an Android app that allows the user to control the cradle and play different lullabies remotely. The project aims to provide a convenient and soothing solution for parents and babies.
The cradle consists of a wooden frame, a mattress, a motor, a speaker, and a microphone. The motor is connected to the frame and can swing the cradle at different speeds and angles. The speaker is attached to the cradle and can play various lullabies from the app. The microphone is used to detect the baby cry and trigger the motor and the speaker.
The app is developed using Android Studio and Firebase. The app has two main features: a cradle controller and a lullaby player. The cradle controller allows the user to adjust the speed and angle of the swing, as well as turn on or off the automatic mode. The lullaby player allows the user to choose from 10 different lullabies and control the volume and duration of the playback.
The prototype is tested with different types and levels of baby cry and evaluated for its accuracy and effectiveness. The results show that the cradle can detect and respond to baby cry with an 85% success rate and can calm down the baby in most cases. The project demonstrates the skills and knowledge of hardware design, app development, and sound processing.