The main idea behind this project is to classify traffic sign images into predefined categories, enabling potential use cases in autonomous driving, driver assistance systems, and road safety.

For this project, I used a traffic sign dataset containing 43 classes of images.
The dataset also included a labels.csv file mapping each class ID to its respective traffic sign name.

• Image Dimensions: 32×32 pixels

• Channels: RGB (converted to grayscale during preprocessing)

• Splits: Training, Validation, and Test sets

The key takeaway from this project was understanding how CNN architectures can effectively extract features from images and classify them with high accuracy.
It also reinforced the importance of preprocessing and data augmentation in improving model performance.

Before training the model, I applied preprocessing steps to improve accuracy and reduce noise:

• Grayscale Conversion – Simplifies data while keeping important features.

• Histogram Equalization – Improves contrast for better feature detection.

• Normalization – Scales pixel values to a range of 0–1.

pythonCopyEditdef grayscale(img):
    return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

def equalize(img):
    return cv2.equalizeHist(img)

def preprocessing(img):
    img = grayscale(img)
    img = equalize(img)
    img = img / 255.0
    return img

Data Augmentation

To make the model more robust and prevent overfitting, I used ImageDataGenerator from Keras for:

• Width and height shifts

• Zoom

• Shear transformation

• Rotation

Model Architecture

I designed a CNN using Keras’ Sequential API with:

• Two convolution layers (60 filters, 5×5 kernel)

• MaxPooling layer

• Two convolution layers (30 filters, 3×3 kernel)

• Dropout layers to reduce overfitting

• Fully connected dense layer (500 neurons)

• Output layer with softmax activation

Training the Model

The model was trained using:

• Batch Size: 32

• Epochs: 10

• Optimizer: Adam

• Loss Function: Categorical Crossentropy

After training, I evaluated the model on the test set to measure accuracy and loss.
I also plotted training vs. validation accuracy and loss to monitor learning trends.

Predictions

For predictions, the workflow was:

1. Load an image.

2. Resize to 32×32.

3. Convert to grayscale.

4. Apply histogram equalization.

5. Normalize pixel values.

6. Predict class and display confidence.

After training for 10 epochs, the model achieved the following performance:

• Test Accuracy:0.9657177925109863

• Test Score: 0.11213602125644684

The training and validation accuracy curves showed consistent improvement, while the loss curves indicated a good fit without significant overfitting.

Accuracy Plot:

Loss Plot:

These results demonstrate that the CNN model can accurately classify traffic signs and is suitable for real-world deployment after further fine-tuning.

I tested the trained model on multiple unseen traffic sign images and achieved consistently good results.

Here is one example:

Predicted class: 9 (No passing), confidence: 0.95

You can view the complete code, dataset preparation steps, and prediction examples here:
https://github.com/Mehar-Zaman-Ali/Traffic-Sign-Recognition-Description

For this project, I used two types of datasets.

• Movie Dataset: Contains the movie ID, title, and genre.

• Ratings Dataset: Contains the user ID, movie ID, and the rating each user gave to multiple movies.

By combining these datasets, I was able to link movie details with their corresponding user ratings, which served as the foundation for building the recommendation system.

I used TfidfVectorizer from sklearn.feature_extraction.text to convert the cleaned movie titles into numerical form using TF-IDF (Term Frequency–Inverse Document Frequency).

pythonCopyEditfrom sklearn.feature_extraction.text import TfidfVectorizer

vectorizer = TfidfVectorizer(ngram_range=(1, 2))
tfidf = vectorizer.fit_transform(movies["clean_title"])

• ngram_range=(1, 2) means the vectorizer considers both single words (unigrams) and pairs of consecutive words (bigrams) when transforming the text into numbers.

• The resulting tfidf matrix represents each movie title as a set of numerical values, allowing us to calculate similarity between titles.

Before performing any of the recommendation steps, I carried out a data cleaning process. This involved removing any characters other than alphabets and numbers from the dataset. For this, I used regular expressions (Regex) to ensure the text was clean and consistent for processing.

import re
def clean_title(title):
    return re.sub("[^a-zA-Z0-9 ]","",title)

Based on these datasets, the recommendation process works as follows:

1. When a user enters a specific movie, I first select all the users who have watched that movie.

2. From those users, I create a list of movies they have rated 4 or above. This helps filter out lower-rated movies and focus on high-quality recommendations.

3. This results in a shorter list of movies, which I then refine further by keeping only the movies that are common among multiple users.

4. Finally, I calculate a similarity score for each remaining movie (using Cosine Similarity or Pearson Correlation) to rank and recommend the most relevant ones.

In addition, I used Jupyter Notebook’s built-in widgets to create an interactive interface. This allowed users to search for a movie and instantly view the top 10 recommended movies based on their input.

GitHub Repository:https://github.com/Mehar-Zaman-Ali/Movie-Recommendation-System

For this project, I used the Mall Customer Segmentation dataset, which contains seven features. However, I focused on just two features for simplicity and visualization purposes: "Annual Income" and "Spending Score".

The key takeaway from this project was understanding how K-Means identifies natural groupings in data without labelled outcomes. It was a valuable introduction to one of the core techniques in unsupervised machine learning.

I also explored and worked with a new Python library called Seaborn, which is built on top of Matplotlib and makes data visualization more intuitive and aesthetically pleasing. Seaborn provides high-level functions that allow you to create visually appealing plots with less code.

As a comparison, I plotted the same scatter plot using both Matplotlib and Seaborn to observe the visual differences. Seaborn made it easier to style the charts and highlight patterns within the data. I included the results at the end of the article, in the Evaluation section.

After analyzing the data, I selected "Annual Income" and "Spending Score" as the features for clustering.

Next, I needed to determine the optimal number of clusters (K) for the K-Means Clustering algorithm. In K-Means, K represents the number of groups or clusters we want to divide the data into.

To find the best value for K, I used the Elbow Method. This technique works by running K-Means for a range of K values and plotting the Within-Cluster Sum of Squares (WCSS). The idea is to identify the "elbow point" in the graph — the point after which increasing K yields minimal improvement. This helps estimate the optimal number of clusters by balancing accuracy and simplicity.

wcss = [] 
for i in range(1, 11): 
    km = KMeans(n_clusters = i)
    km.fit(m) 
    wcss.append(km.inertia_)
plt.plot(range(1,11),wcss)

Here is the Elbow Point graph that I plotted to determine the optimal number of clusters for K-Means.

After determining the optimal value of K, I applied K-Means clustering to the dataset. This segmented the data into distinct groups, giving us the desired output. Below is the scatter plot visualizing the clustered groups.

This is the plot generated using Matplotlib. The purpose of including both Matplotlib and Seaborn visualizations is to highlight how each library displays the same data, showcasing the visual appeal and style differences between the two.

GitHub Repository:https://github.com/Mehar-Zaman-Ali/mall-customer-segmentation