- \n
- Introduction<\/a><\/li>\n
- Syntax<\/a><\/li>\n
- Examples<\/a><\/li>\n
- Frequently Asked Questions<\/a><\/li>\n<\/ul>\n
That said, let’s dive into the sklearn make_classification function.<\/p>\n
<\/a><\/p>\n
A Quick Introduction to Sklearn make_classification<\/h2>\n
The sklearn make_classification function allows Python<\/a> users to create datasets that they can use for classification models<\/a>.<\/p>\n
It allows you to make data with binary labels and multiclass labels.<\/p>\n
For example, here is a plot of a binary dataset that I made with make_classification:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2023\/09\/sklearn-make-classification_binary-scatter-2d.png\")
<\/p>\n(I’ll show you how to create this exact dataset later.)<\/p>\n
And importantly, it provides functionality that allows you to specify things like:<\/p>\n
- \n
- the number of features<\/li>\n
- the number of classes<\/li>\n
- the number of informative<\/em> features<\/li>\n
- the number of examples<\/li>\n
- … and many other details<\/li>\n<\/ul>\n
Now that we’ve seen a brief overview of its capabilities, let’s delve deeper into the syntax of make_classification to understand how we can use it properly.<\/p>\n
<\/a><\/p>\n
The Syntax of Sklearn make_classification<\/h2>\n
Here, I’m going to explain the syntax of the Scikit Learn make_classification function.<\/p>\n
I’ll explain the high-level syntax, but also some of the details about the most important parameters.<\/p>\n
A quick note<\/h4>\n
Everything I’m about to explain assumes that you have Scikit Learn installed on your machine, and that you’ve imported make_classification as follows:<\/p>\n
\r\nfrom sklearn.datasets import make_classification\r\n<\/pre>\n
With that said, let’s look at the syntax.<\/p>\n
make_classification syntax<\/h3>\n
The basic syntax, is very, very simple.<\/p>\n
Assuming that you’ve imported the function as described above, you can call the function by typing
make_classification()<\/code>.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2023\/09\/sklearn-make-classification_syntax.png\")
<\/p>\nThere are a few important parameters as well that you can specify inside the parenthesis:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2023\/09\/sklearn-make-classification_syntax-parameters.png\")
<\/p>\nIn some sense, the parameters are the most important part of the function, because they determine the exact structure and content of the output dataset.<\/p>\n
That being the case, let’s quickly discuss the important parameters.<\/p>\n
<\/a><\/p>\n
The Parameters of make classification<\/h3>\n
The Scikit Learn make classification function has quite a few parameters, but I believe that the most important are:<\/p>\n
- \n
n_samples<\/code><\/li>\nn_features<\/code><\/li>\nn_classes<\/code><\/li>\nn_informative<\/code><\/li>\nn_redundant<\/code><\/li>\nclass_sep<\/code><\/li>\nn_clusters_per_class<\/code><\/li>\nrandom_state<\/code><\/li>\n<\/ul>\nLet’s look at each of these, one at a time.<\/p>\n
n_samples<\/code> (required)<\/h6>\nThe
n_samples<\/code> parameter controls the number of samples in the output dataset.<\/p>\nSaid differently, it controls the number of examples (or, the number of rows of data, if you’re thinking of a simple row-and-column dataset).<\/p>\n
By default, this is set to 100.<\/p>\n
n_features<\/code><\/h6>\nThe
n_features<\/code> parameter controls the number of features in the output dataset.<\/p>\nRemember, the features are like the inputs to a machine learning model. They are the columns that a machine learning algorithm learns from in order to make a prediction. Features are like the inputs to a model, and labels\/targets are like the outputs of a model (to learn a bit more about features and labels, read our blog post on Supervised vs Unsupervised machine learning<\/a>).<\/p>\n
This will include the informative features, redundant features, and repeated features (if you use them when you create your dataset).<\/p>\n
By default, this parameter is set to 20.<\/p>\n
n_classes<\/code><\/h6>\nThe
n_classes<\/code> parameter controls the number of classes in the output dataset.<\/p>\nAs mentioned above, the classes are the different possible categories for the target variable (remember that in supervised learning<\/a> the dataset has a target\/label variable that we’re trying to predict).<\/p>\n
By default, this is set to
n_classes = 2<\/code>, so by default, make_classification will produce a binary dataset.<\/p>\nn_informative<\/code><\/h6>\nThe
n_informative<\/code> parameter controls the number ofinformative<\/code> features in the output dataset.<\/p>\nSo what does informative mean? <\/p>\n
An informative feature is one that has a relationship with the target label. It carries information that enables us to learn how to predict the categorical values in the data.<\/p>\n
So the rest of the features (the un-informative ones) may be noisy or otherwise irrelevant.<\/p>\n
Introducing uninformative (or noisy) features into a dataset be useful, especially for experimental or educational purposes. <\/p>\n
For example, uninformative features can:<\/p>\n
- \n
- Make the dataset more realistic, since many real-world datasets have irrelevant features.<\/li>\n
- Help with testing model robustness, since testing a model on data with irrelevant features can help gauge how it handles irrelevant inputs.<\/li>\n
- Help with practicing feature selection, since we typically use feature selection to remove irrelevant features.<\/li>\n
- Help test regularization, since regularization typically mitigates the effects of irrelevant or noisy featuers.<\/li>\n<\/ul>\n
So it may sound a bit strange to have uninformative features, but if we’re making a dataset for machine learning practice or algorithm evaluation, it may actually be useful for the synthetic dataset to have uninformative features.<\/p>\n
n_redundant<\/code><\/h6>\nn_redundant<\/code> enables you to specify how many redundant features there are.<\/p>\nIt might seem odd, but redundant features can be useful if you’re practicing machine learning or testing a particular algorithm.<\/p>\n
We can use redundant features to:<\/p>\n
- \n
- Practice feature selection methods<\/li>\n
- Evaluate model performance in the face of redundant features<\/li>\n
- Evaluate the regularization ability of an algorithm<\/li>\n<\/ul>\n
And more.<\/p>\n
So like the “uninformative” features discussed earlier, redundant features can serve a useful purpose when we practice ML or try to evaluate algorithm performance.<\/p>\n
class_sep<\/code><\/h6>\nThe
class_sep<\/code> parameter (short for “class separation”) controls the amount of separability between the generated classes.<\/p>\nThere are some algorithm types where want (or need) the classes to be perfectly separable. <\/p>\n
There are some algorithm types that allow the classes to overlap somewhat (so overlapping classes is good for testing such algorithms).<\/p>\n
class_sep<\/code> allows you to control the degree to which the classes overlap.<\/p>\nn_clusters_per_class<\/code><\/h6>\nn_clusters_per_class<\/code> allows you to specify how many clusters will be generated for every class.<\/p>\nBy default, this is set to 2.<\/p>\n
Why would you want to use this?<\/p>\n
In some classification datasets, all of the data points for a particular class will form a tight “cluster”. They will be grouped together in feature space. <\/p>\n
But other times, members of a single class might form multiple clusters of data … they might form separate groups.<\/p>\n
Datasets where classes have multiple clusters are generally more complex, and a synthetic<\/em> dataset with multiple clusters per class may be more “realistic.” <\/p>\n
Essentially, the n_clusters_per_class parameter lets you emulate this complexity and real-worldness in the synthetic data created by make_classification.<\/p>\n
random_state<\/code><\/h6>\nThe random_state parameter allows us to set a seed for the random number generator.<\/p>\n
This ensures that any process or function that utilizes random numbers can be reproduced exactly every time we run it.<\/p>\n
Essentially, this enables reproducibility when the code is run multiple times, whether by the same individual or different people.<\/p>\n
If you want to learn more about seeds and random number generators, read our tutorial on Numpy Random Seed<\/a>.<\/p>\n
Other Parameters<\/h5>\n
There are several other features that I’m leaving out here for the sake of brevity, like
weights<\/code>,flip_y<\/code>,hypercube<\/code>, and several others.<\/p>\nHowever, many of these will be somewhat rarely used, so in the beginning, you may want to avoid using them unless absolutely necessary.<\/p>\n
The Output of make_classification<\/h3>\n
The output of the Scikit Learn make_classification function is 2 Numpy arrays<\/a>.<\/p>\n
The first is a Numpy array with shape
(n_samples, n_features)<\/code>. This is the so-calledX<\/code> array, which contains the feature data.<\/p>\nThe second array is a Numpy array with shape
(n_samples,)<\/code>. This is the so-calledy<\/code> array, which contains the labels. It’s essentially a vector of labels associated with every example inX<\/code>. Importantly, they<\/code> array contains integers representing the classes, with the number of unique integers being determined by then_classes<\/code> parameter.<\/p>\n<\/a><\/p>\n
Examples of How to Use Make Classification<\/h2>\n
Now that I’ve shown you the syntax of make_classification, let’s look at a couple of examples.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Generate Data For Logistic Regression<\/a><\/li>\n
- Create a 2D dataset with separated classes<\/a><\/li>\n<\/ul>\n
Run this code first<\/h4>\n
Before you run the examples, make sure that you import the
make_classification<\/code> function with this code:<\/p>\n\r\nfrom sklearn.datasets import make_classification\r\n\r\nimport matplotlib.pyplot as plt\r\nimport seaborn as sns\r\n<\/pre>\n
Here, we’re also importing Seaborn and Matplotlib’s Pyplot, which we’ll use to visualize the data we generate.<\/p>\n
Once you run it, you’ll be ready to get started.<\/p>\n
<\/a><\/p>\n
EXAMPLE 1: Generate Data For Logistic Regression<\/h3>\n
Here, we’re going to generate some data that will be well suited for a Logistic Regression model.<\/p>\n
We’re going to make a dataset with:<\/p>\n
- \n
- 1000 examples (i.e., samples)<\/li>\n
- 1 feature (an informative feature)<\/li>\n
- 1 cluster per class<\/li>\n
- mild class separation<\/li>\n<\/ul>\n
And we’re going to initialize a random seed for the random number generator <\/p>\n
\r\nX, y = make_classification(n_samples = 1000\r\n ,n_features = 1\r\n ,n_informative = 1\r\n ,n_redundant = 0\r\n ,n_clusters_per_class = 1\r\n ,class_sep = 2\r\n ,random_state = 2\r\n )\r\n<\/pre>\n
And let’s visualize this data with a Seaborn scatterplot<\/a>, so you can see it:<\/p>\n
\r\nplt.style.use('fivethirtyeight')\r\nsns.scatterplot(x = X.flatten(), y = y, hue = y)\r\n<\/pre>\nOUT:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2023\/09\/make-classification_logistic-regression-data.png\")
<\/p>\nHere, we have a dataset with 1 feature and 2 classes.<\/p>\n
We’ll be able to fit a logistic regression model<\/a> to this, which I’ll show you how to do in a future blog post.<\/p>\n
- Create a 2D dataset with separated classes<\/a><\/li>\n<\/ul>\n
- Generate Data For Logistic Regression<\/a><\/li>\n
- Syntax<\/a><\/li>\n