5 Free Datasets to Kickstart Your Machine Learning Projects Today

 

5 Free Datasets to Kickstart Your Machine Learning Projects Today
Image by Editor | Midjourney

There are many free datasets online that help you practice and learn. These datasets allow you to try different machine learning techniques and improve your skills. You can find these datasets on platforms like Kaggle and UCI Machine Learning Repository. Here are five free datasets that can help you start your machine learning projects.

1. Iris Dataset

Description: The Iris Dataset features information about three types of iris flowers: Setosa, Versicolor, and Virginica. The dataset consists of four attributes: sepal length, sepal width, petal length, and petal width.

Use Cases:

• Training supervised learning algorithms like decision trees, k-nearest neighbors, and support vector machines.
• Performing exploratory data analysis (EDA) and visualizations like scatter plots and pair plots.
• Practicing feature scaling and selection techniques.

Link: Iris Dataset on UCI Machine Learning Repository

2. MNIST Handwritten Digits

Description: The MNIST dataset contains 70,000 pictures of handwritten numbers ranging from 0 to 9. Each picture is a grayscale image with a size of 28 by 28 pixels.

Use Cases:

• Training deep learning models for handwritten digit classification.
• Learning about image processing techniques like image normalization and augmentation.
• Understanding how to build models that can classify images into different categories.

Link: MNIST Dataset on Yann LeCun Website
 

3. Boston Housing Dataset

Description: This dataset contains information about housing prices in Boston suburbs. It includes features like crime rate, property age, and number of rooms.

Use Cases:

• Predicting housing prices using linear regression or other regression models.
• Performing feature engineering, such as transforming variables or dealing with multicollinearity.
• Practicing cross-validation and hyperparameter tuning for regression tasks.

Link: Boston Housing Dataset on Kaggle

4. Wine Quality Dataset

Description: This dataset has information about red and white wines. It includes their chemical properties and quality ratings. It contains features like acidity, sugar content, and alcohol levels.

Use Cases:

• Determining quality of using its chemical characteristics.
• Training both classification and regression models, depending on the nature of the prediction.
• Finding methods for feature scaling and dimensionality reduction.

Link: Wine Quality Dataset on UCI Machine Learning Repository

5. Titanic Dataset

Description: The Titanic dataset includes details about passengers on the Titanic, such as their age, gender, class, and whether they survived the disaster.

Use Cases:

• Predicting whether a passenger survived the Titanic disaster using classification algorithms like logistic regression or random forests.
• Practicing data preprocessing tasks like encoding categorical variables and normalizing numerical features.
• Handling missing data and performing feature engineering on real-world data.

Link: Titanic Dataset on Kaggle
 

Wrapping Up

In conclusion, these five free datasets are perfect for starting your machine learning projects. They cover several tasks, from classification to regression. Take advantage of these datasets to explore machine learning techniques and build your portfolio.

10 Machine Learning Algorithms Explained Using Real-World Analogies

 

10 Machine Learning Algorithms Explained Using Real-World Analogies

When I was in high school and studied complex mathematics problems, I always used to think about why we were studying them or why they were useful. I was unable to understand and find their usage in the real world. Since machine learning is also a trending topic that many people want to explore, the complex mathematics and abstraction behind machine learning algorithms make it difficult for beginners to appreciate and learn its usage.

This is where analogous learning comes into play. It allows you to associate real-world analogies with complex concepts that help you to stay curious and think creatively. This really helps when you actually apply these algorithms to solve real-world problems later on. Taking motivation from this approach, I will explain 10 common machine learning algorithms by associating them with real-world analogies, so let’s get started.

1. Linear Regression

Linear regression is a supervised machine learning algorithm that tries to fit the best straight line between your features and your target variable so that the difference between the actual and the predicted value is as minimal as possible.

Analogy: Suppose you are a gardener and you want to test what is an ideal amount of fertilizer that you should be giving to a plant to increase its growth. So for that purpose, you record the amount of fertilizer (feature/independent variable) and also measure the corresponding plant’s growth (dependent or target variable) for one month. Now, you have the information and you plot it on a scatter plot and try to figure out the best straight line that passes through these points in such a way that the deviation of all the points from the line is minimum. Once you have this line, you can predict future plant growth based on the amount of fertilizer used.

2. Logistic Regression

It is somewhat similar to linear regression and a supervised learning problem, but linear regression predicts the continuous target variable while logistic regression is used for binary classification problems where it predicts the probability of a binary outcome like the probability of yes or no, true or false.

Analogy: For example, if you watch America’s Got Talent, we know that there are only 2 choices: either the candidate will be selected for the next round or not. So, you consider various factors like their current performance, past experience, whether it’s a unique act or not, and based on this, you decide how much capability the candidate has to be successful in the next round. Based on this, you either press the red (reject) button on or the green (accept) one.

3. Decision Tree

Decision tree is a supervised learning algorithm that recursively divides your data into subsets based on the feature values. Each division on the node is actually a decision that decides the direction of the traversal and helps in making predictions.

Analogy: Have you ever played that “20 Questions” game with your friend? That’s exactly how decision trees work. Let me share what happens in this game. So, your friend thinks of something that you have to guess and all you can do is ask them yes/no questions to narrow down the possible answers. Each answer helps you make a decision and eliminates options until you guess the correct answer.

4. Random Forest Algorithm

Random forest is an ensemble learning technique that uses multiple decision trees trained on various parts of the data. It then combines the predictions by each tree to make a final decision.

Analogy: Consider a committee of investors and equity holders at a business who need to make a decision regarding a new deal. Everyone has their own thought process and experiences. Based on their analysis, each of them provides their judgment. In the end, all the judgments are combined to make the final decision.

5. Support Vector Machine (SVM)

SVM is a supervised machine learning algorithm that divides the classes using a straight line (hyperplane) in such a way that the distance between them is maximum. When a new data point comes in, it’s easier to identify which group/class it belongs to.

Analogy: If you’re a sports lover, you would understand the rivalry between the fans of 2 opposing teams on the ground. So, you try to separate these 2 groups as far as possible by maybe, let’s say, tying a red ribbon, and when a new person joins in, based on features like the shirt they are wearing or which team they support, you may provide the seating arrangement accordingly.

6. Naive Bayes Algorithm

It is a supervised machine learning algorithm based on Bayes’ Theorem and assumes that the features are independent. It computes the probability of each class keeping in mind some prior information, and then the class with the highest probability is selected. It is mainly used for classification problems.

Analogy: We are all aware of spam emails, right? So basically, the filter looks out for some common words like “free”, “discount,” “limited time,” or “click here,” without considering the context in which these words appear. Although this may classify some cases incorrectly, it saves a huge amount of time when it comes to processing tons of emails. It considers these spam words as independent features to determine the likelihood of an email being spam or not.

7. K-Nearest Neighbors (KNN) Algorithm

KNN is a supervised learning algorithm that assumes similar data points will be closer to each other in feature space (just like close friends sitting together in class). It makes prediction about the label of an unknown data point using its K nearest known neighbors, where it is a hyperparameter and represents the number of voting neighbours.

Analogy: Let’s say you want to try some new restaurants and have a couple of options. So you ask your friends (neighbors in KNN) for recommendations. Each of them recommends their favorite place that they have visited, and the place that gets the majority vote is then what you finalize to visit.

8. K-means

K-means is an unsupervised learning algorithm that assigns data points to unique clusters based on their position. It starts by randomly initializing the centroids and calculating the distance of each point to these centroids. Each point is then assigned to the cluster of the nearest centroid. The new data points within each cluster are averaged to find new centroids. This process repeats until the centroids no longer change, meaning that the data points have been perfectly classified into clusters.

Analogy: Consider that you are part of a reading community and they have to create 3 groups of, let’s say, 18 students. Initially, they will assign them randomly into 3 groups of 6 people. Then in the 2nd iteration, they reassign based on their interests gathered from a form. Then after their interaction, they make changes unless the final groups are created with people that have aligned interests.

9. Principal Component Analysis

PCA is an unsupervised learning algorithm. It is a dimensionality reduction technique that identifies the principal (important) components of the data and maps it to a lower-dimensional space making it easier to analyze.

Analogy: Most of us have traveled somewhere and I know it’s a headache to pack things. Let’s say we just have one suitcase, so what do we do? We start by first filling it in with important items and then try to find a way to compress the less important ones or remove them from our bag. That’s exactly how PCA works, identifying important features and condensing or removing the less relevant ones.

10. Gradient Boosting

It is an ensemble learning algorithm that combines multiple weak models to create a strong model. It works iteratively where each model tries to improve the errors made by the previous model, increasing the overall performance.

Analogy: Has it ever happened that you were initially struggling with a subject but gradually improved? What’s the general approach typically followed in that situation? You take a test, receive the grades, and then work on your shortcomings or the topics where you lack understanding. This process gradually improves your overall performance in that subject.

This brings me to the end of my article. I really enjoy explaining these concepts using analogies, and I hope you find them as helpful as I do. Let me know in the comments if you enjoyed this approach or if you have suggestions for other topics!

Tips for Effective Feature Selection in Machine Learning

Tips for Effective Feature Selection in Machine Learning
Image by Author | Created on Canva

When training a machine learning model, you may sometimes work with datasets with a large number of features. However, only a small subset of these features will actually be important for the model to make predictions. Which is why you need feature selection to identify these helpful features.

This article covers useful tips for feature selection. We’ll not look at feature selection techniques in depth. But we’ll cover simple yet effective tips to understand the most relevant features in your dataset. We’ll not be working with any specific dataset. But you can try them out on a sample dataset of choice.

Let’s get started.

1. Understand the Data

You’re probably tired of reading this tip. But there’s no better way to approach any problem than to understand the problem you’re trying to solve and the data you’re working with.

So understanding your data is the first and most important step in feature selection. This involves exploring the dataset to better understand the distribution of variables, understanding the relationships between features, identifying potential anomalies and relevant features.

Key tasks in exploring data include checking for missing values, assessing data types, and generating summary statistics for numerical features.

This code snippet loads the dataset, provides a summary of data types and non-null values, generates basic descriptive statistics for numerical columns, and checks for missing values.

import pandas as pd   # Load your dataset df = pd.read_csv('your_dataset.csv')   # Get an overview of the dataset print(df.info())   # Generate summary statistics for numerical features print(df.describe())   # Check for missing values in each column print(df.isnull().sum())

These steps help you understand more about the features in your data and potential data quality issues which need addressing before proceeding with feature selection.

2. Remove Irrelevant Features

Your dataset may have a large number of features. But not all of them will contribute to the predictive power of your model.

Such irrelevant features can add noise and increase model complexity without making it much effective. It’s essential to remove such features before training your model. And this should be straightforward if you have understood and explored the dataset in detail.

For example, you can drop a subset of irrelevant features like so:

# Assuming 'feature1', 'feature2', and 'feature3' are irrelevant features df = df.drop(columns=['feature1', 'feature2', 'feature3'])

In your code, replace ‘feature1’, ‘feature2’, and ‘feature3’ with the actual names of the irrelevant features you want to drop.

This step simplifies the dataset by removing unnecessary information, which can improve both model performance and interpretability.

3. Use Correlation Matrix to Identify Redundant Features

Sometimes you’ll have features that are highly correlated. A correlation matrix shows the correlation coefficients between pairs of features.

Highly correlated features can often be redundant, providing similar information to the model. In such cases, you can remove one of the correlated features can help.

Here’s the code to identify highly correlated pairs of features on the dataset:

import seaborn as sns import matplotlib.pyplot as plt   # Compute the correlation matrix corr_matrix = df.corr()   # Plot the heatmap of the correlation matrix sns.heatmap(corr_matrix, annot=True, cmap='coolwarm') plt.show()   # Identify highly correlated pairs threshold = 0.8 corr_pairs = corr_matrix.abs().unstack().sort_values(kind="quicksort", ascending=False) high_corr = [(a, b) for a, b in corr_pairs.index if a != b and corr_pairs[(a, b)] > threshold]

Essentially, the above code aims to identify pairs of features with high correlation—those with an absolute correlation value greater than 0.8—excluding self-correlations. These highly correlated feature pairs are stored in a list for further analysis. You can then review and select features you wish to retain for the next steps.

4. Use Statistical Tests

You can use statistical tests to help you determine the importance of features relative to the target variable. And to do so, you can use functionality from scikit-learn’s feature_selection module.

The following snippet uses the chi-square test to evaluate the importance of each feature relative to the target variable. And the SelectKBest method is used to select the top features with the highest scores.

from sklearn.feature_selection import chi2, SelectKBest   # Assume target variable is categorical X = df.drop(columns=['target']) y = df['target']   # Apply chi-square test chi_selector = SelectKBest(chi2, k=10) X_kbest = chi_selector.fit_transform(X, y)   # Display selected features selected_features = X.columns[chi_selector.get_support(indices=True)] print(selected_features)

Doing so reduces the feature set to the most relevant variables, which can significantly improve model performance.

5. Use Recursive Feature Elimination (RFE)

Recursive Feature Elimination (RFE) is a feature selection technique that recursively removes the least important features and builds the model with the remaining features. This continues until the specified number of features is reached.

Here’s how you can use RFE to find the five most relevant features when building a logistic regression model.

from sklearn.feature_selection import RFE from sklearn.linear_model import LogisticRegression from sklearn.model_selection import train_test_split   # Say 'X' is the feature matrix and 'y' is the target # Split into training and test sets X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=25)   # Create a logistic regression model model = LogisticRegression()   # Apply RFE on the training set to select the top 5 features rfe = RFE(model, n_features_to_select=5) X_train_rfe = rfe.fit_transform(X_train, y_train)   X_test_rfe = rfe.transform(X_test)   # Display selected features selected_features = X.columns[rfe.support_] print(selected_features)

You can, therefore, use RFE to select the most important features by recursively removing the least important ones.

Wrapping Up

Effective feature selection is important in building robust machine learning models. To recap: you should understand your data, remove irrelevant features, identify redundant features using correlation, apply statistical tests, and use Recursive Feature Elimination (RFE) as needed to your model’s performance.

Happy feature selection! And if you’re looking for tips on feature engineering, read Tips for Effective Feature Engineering in Machine Learning.