Numerical input variables may have a highly skewed or non-standard distribution.<\/p>\n
This could be caused by outliers in the data, multi-modal distributions, highly exponential distributions, and more.<\/p>\n
Many machine learning algorithms prefer or perform better when numerical input variables and even output variables in the case of regression have a standard probability distribution, such as a Gaussian (normal) or a uniform distribution.<\/p>\n
The quantile transform provides an automatic way to transform a numeric input variable to have a different data distribution, which in turn, can be used as input to a predictive model.<\/p>\n
In this tutorial, you will discover how to use quantile transforms to change the distribution of numeric variables for machine learning.<\/p>\n
After completing this tutorial, you will know:<\/p>\n
- \n
- Many machine learning algorithms prefer or perform better when numerical variables have a Gaussian or standard probability distribution.<\/li>\n
- Quantile transforms are a technique for transforming numerical input or output variables to have a Gaussian or uniform probability distribution.<\/li>\n
- How to use the QuantileTransformer to change the probability distribution of numeric variables to improve the performance of predictive models.<\/li>\n<\/ul>\n
Let’s get started.<\/p>\n
![\"How](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/How-to-Use-Quantile-Transforms-for-Machine-Learning.jpg\")
<\/p>\nHow to Use Quantile Transforms for Machine Learning
Photo by Bernard Spragg. NZ<\/a>, some rights reserved.<\/p>\n<\/div>\nTutorial Overview<\/h2>\n
This tutorial is divided into five parts; they are:<\/p>\n
- \n
- Change Data Distribution<\/li>\n
- Quantile Transforms<\/li>\n
- Sonar Dataset<\/li>\n
- Normal Quantile Transform<\/li>\n
- Uniform Quantile Transform<\/li>\n<\/ol>\n
Change Data Distribution<\/h2>\n
Many machine learning algorithms perform better when the distribution of variables is Gaussian.<\/p>\n
Recall that the observations for each variable may be thought to be drawn from a probability distribution. The Gaussian is a common distribution with the familiar bell shape. It is so common that it is often referred to as the “normal<\/em>” distribution.<\/p>\n
For more on the Gaussian probability distribution, see the tutorial:<\/p>\n
- \n
- Continuous Probability Distributions for Machine Learning<\/a><\/li>\n<\/ul>\n
Some algorithms, like linear regression<\/a> and logistic regression<\/a>, explicitly assume the real-valued variables have a Gaussian distribution. Other nonlinear algorithms may not have this assumption, yet often perform better when variables have a Gaussian distribution.<\/p>\n
This applies both to real-valued input variables in the case of classification and regression tasks, and real-valued target variables in the case of regression tasks.<\/p>\n
Some input variables may have a highly skewed distribution, such as an exponential distribution where the most common observations are bunched together. Some input variables may have outliers that cause the distribution to be highly spread.<\/p>\n
These concerns and others, like non-standard distributions and multi-modal distributions, can make a dataset challenging to model with a range of machine learning models.<\/p>\n
As such, it is often desirable to transform each input variable to have a standard probability distribution, such as a Gaussian (normal) distribution or a uniform distribution.<\/p>\n
Quantile Transforms<\/h2>\n
A quantile transform will map a variable’s probability distribution to another probability distribution.<\/p>\n
Recall that a quantile function<\/a>, also called a percent-point function (PPF), is the inverse of the cumulative probability distribution (CDF). A CDF is a function that returns the probability of a value at or below a given value. The PPF is the inverse of this function and returns the value at or below a given probability.<\/p>\n
The quantile function ranks or smooths out the relationship between observations and can be mapped onto other distributions, such as the uniform or normal distribution.<\/p>\n
The transformation can be applied to each numeric input variable in the training dataset and then provided as input to a machine learning model to learn a predictive modeling task.<\/p>\n
This quantile transform is available in the scikit-learn Python machine learning library via the QuantileTransformer class<\/a>.<\/p>\n
The class has an “output_distribution<\/em>” argument that can be set to “uniform<\/em>” or “random<\/em>” and defaults to “uniform<\/em>“.<\/p>\n
It also provides a “n_quantiles<\/em>” that determines the resolution of the mapping or ranking of the observations in the dataset. This must be set to a value less than the number of observations in the dataset and defaults to 1,000.<\/p>\n
We can demonstrate the QuantileTransformer<\/em> with a small worked example. We can generate a sample of random Gaussian numbers<\/a> and impose a skew on the distribution by calculating the exponent. The QuantileTransformer<\/em> can then be used to transform the dataset to be another distribution, in this cases back to a Gaussian distribution.<\/p>\n
The complete example is listed below.<\/p>\n
# demonstration of the quantile transform\r\nfrom numpy import exp\r\nfrom numpy.random import randn\r\nfrom sklearn.preprocessing import QuantileTransformer\r\nfrom matplotlib import pyplot\r\n# generate gaussian data sample\r\ndata = randn(1000)\r\n# add a skew to the data distribution\r\ndata = exp(data)\r\n# histogram of the raw data with a skew\r\npyplot.hist(data, bins=25)\r\npyplot.show()\r\n# reshape data to have rows and columns\r\ndata = data.reshape((len(data),1))\r\n# quantile transform the raw data\r\nquantile = QuantileTransformer(output_distribution='normal')\r\ndata_trans = quantile.fit_transform(data)\r\n# histogram of the transformed data\r\npyplot.hist(data_trans, bins=25)\r\npyplot.show()<\/pre>\n
Running the example first creates a sample of 1,000 random Gaussian values and adds a skew to the dataset.<\/p>\n
A histogram is created from the skewed dataset and clearly shows the distribution pushed to the far left.<\/p>\n
![\"Histogram](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Histogram-of-Skewed-Gaussian-Distribution2.png\")
<\/p>\nHistogram of Skewed Gaussian Distribution<\/p>\n<\/div>\n
Then a QuantileTransformer<\/em> is used to map the data distribution Gaussian and standardize the result, centering the values on the mean value of 0 and a standard deviation of 1.0.<\/p>\n
A histogram of the transform data is created showing a Gaussian shaped data distribution.<\/p>\n
![\"Histogram](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Histogram-of-Skewed-Gaussian-Data-After-Quantile-Transform.png\")
<\/p>\nHistogram of Skewed Gaussian Data After Quantile Transform<\/p>\n<\/div>\n
In the following sections will take a closer look at how to use the quantile transform on a real dataset.<\/p>\n
Next, let’s introduce the dataset.<\/p>\n
Sonar Dataset<\/h2>\n
The sonar dataset is a standard machine learning dataset for binary classification.<\/p>\n
It involves 60 real-valued inputs and a two-class target variable. There are 208 examples in the dataset and the classes are reasonably balanced.<\/p>\n
A baseline classification algorithm can achieve a classification accuracy of about 53.4 percent using repeated stratified 10-fold cross-validation. Top performance<\/a> on this dataset is about 88 percent using repeated stratified 10-fold cross-validation.<\/p>\n
The dataset describes radar returns of rocks or simulated mines.<\/p>\n
You can learn more about the dataset from here:<\/p>\n
- \n
- Sonar Dataset<\/a><\/li>\n
- Sonar Dataset Description<\/a><\/li>\n<\/ul>\n
No need to download the dataset; we will download it automatically from our worked examples.<\/p>\n
First, let’s load and summarize the dataset. The complete example is listed below.<\/p>\n
# load and summarize the sonar dataset\r\nfrom pandas import read_csv\r\nfrom pandas.plotting import scatter_matrix\r\nfrom matplotlib import pyplot\r\n# Load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/sonar.csv\"\r\ndataset = read_csv(url, header=None)\r\n# summarize the shape of the dataset\r\nprint(dataset.shape)\r\n# summarize each variable\r\nprint(dataset.describe())\r\n# histograms of the variables\r\ndataset.hist()\r\npyplot.show()<\/pre>\n
Running the example first summarizes the shape of the loaded dataset.<\/p>\n
This confirms the 60 input variables, one output variable, and 208 rows of data.<\/p>\n
A statistical summary of the input variables is provided showing that values are numeric and range approximately from 0 to 1.<\/p>\n
(208, 61)\r\n 0 1 2 ... 57 58 59\r\ncount 208.000000 208.000000 208.000000 ... 208.000000 208.000000 208.000000\r\nmean 0.029164 0.038437 0.043832 ... 0.007949 0.007941 0.006507\r\nstd 0.022991 0.032960 0.038428 ... 0.006470 0.006181 0.005031\r\nmin 0.001500 0.000600 0.001500 ... 0.000300 0.000100 0.000600\r\n25% 0.013350 0.016450 0.018950 ... 0.003600 0.003675 0.003100\r\n50% 0.022800 0.030800 0.034300 ... 0.005800 0.006400 0.005300\r\n75% 0.035550 0.047950 0.057950 ... 0.010350 0.010325 0.008525\r\nmax 0.137100 0.233900 0.305900 ... 0.044000 0.036400 0.043900\r\n\r\n[8 rows x 60 columns]<\/pre>\n
Finally a histogram is created for each input variable.<\/p>\n
If we ignore the clutter of the plots and focus on the histograms themselves, we can see that many variables have a skewed distribution.<\/p>\n
The dataset provides a good candidate for using a quantile transform to make the variables more-Gaussian.<\/p>\n
![\"Histogram](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Histogram-Plots-of-Input-Variables-for-the-Sonar-Binary-Classification-Dataset.png\")
<\/p>\nHistogram Plots of Input Variables for the Sonar Binary Classification Dataset<\/p>\n<\/div>\n
Next, let’s fit and evaluate a machine learning model on the raw dataset.<\/p>\n
We will use a k-nearest neighbor algorithm with default hyperparameters and evaluate it using repeated stratified k-fold cross-validation<\/a>. The complete example is listed below.<\/p>\n
# evaluate knn on the raw sonar dataset\r\nfrom numpy import mean\r\nfrom numpy import std\r\nfrom pandas import read_csv\r\nfrom sklearn.model_selection import cross_val_score\r\nfrom sklearn.model_selection import RepeatedStratifiedKFold\r\nfrom sklearn.neighbors import KNeighborsClassifier\r\nfrom sklearn.preprocessing import LabelEncoder\r\nfrom matplotlib import pyplot\r\n# load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/sonar.csv\"\r\ndataset = read_csv(url, header=None)\r\ndata = dataset.values\r\n# separate into input and output columns\r\nX, y = data[:, :-1], data[:, -1]\r\n# ensure inputs are floats and output is an integer label\r\nX = X.astype('float32')\r\ny = LabelEncoder().fit_transform(y.astype('str'))\r\n# define and configure the model\r\nmodel = KNeighborsClassifier()\r\n# evaluate the model\r\ncv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)\r\nn_scores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')\r\n# report model performance\r\nprint('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))<\/pre>\nRunning the example evaluates a KNN model on the raw sonar dataset.<\/p>\n
We can see that the model achieved a mean classification accuracy of about 79.7 percent, showing that it has skill (better than 53.4 percent) and is in the ball-park of good performance (88 percent).<\/p>\n
Accuracy: 0.797 (0.073)<\/pre>\n
Next, let’s explore a normal quantile transform of the dataset.<\/p>\n
Normal Quantile Transform<\/h2>\n
It is often desirable to transform an input variable to have a normal probability distribution to improve the modeling performance.<\/p>\n
We can apply the Quantile transform using the QuantileTransformer<\/em> class and set the “output_distribution<\/em>” argument to “normal<\/em>“. We must also set the “n_quantiles<\/em>” argument to a value less than the number of observations in the training dataset, in this case, 100.<\/p>\n
Once defined, we can call the fit_transform()<\/em> function and pass it to our dataset to create a quantile transformed version of our dataset.<\/p>\n
...\r\n# perform a normal quantile transform of the dataset\r\ntrans = QuantileTransformer(n_quantiles=100, output_distribution='normal')\r\ndata = trans.fit_transform(data)<\/pre>\n
Let’s try it on our sonar dataset.<\/p>\n
The complete example of creating a normal quantile transform of the sonar dataset and plotting histograms of the result is listed below.<\/p>\n
# visualize a normal quantile transform of the sonar dataset\r\nfrom pandas import read_csv\r\nfrom pandas import DataFrame\r\nfrom pandas.plotting import scatter_matrix\r\nfrom sklearn.preprocessing import QuantileTransformer\r\nfrom matplotlib import pyplot\r\n# load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/sonar.csv\"\r\ndataset = read_csv(url, header=None)\r\n# retrieve just the numeric input values\r\ndata = dataset.values[:, :-1]\r\n# perform a normal quantile transform of the dataset\r\ntrans = QuantileTransformer(n_quantiles=100, output_distribution='normal')\r\ndata = trans.fit_transform(data)\r\n# convert the array back to a dataframe\r\ndataset = DataFrame(data)\r\n# histograms of the variables\r\ndataset.hist()\r\npyplot.show()<\/pre>\n
Running the example transforms the dataset and plots histograms of each input variable.<\/p>\n
We can see that the shape of the histograms for each variable looks very Gaussian as compared to the raw data.<\/p>\n
![\"Histogram](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Histogram-Plots-of-Normal-Quantile-Transformed-Input-Variables-for-the-Sonar-Dataset.png\")
<\/p>\nHistogram Plots of Normal Quantile Transformed Input Variables for the Sonar Dataset<\/p>\n<\/div>\n
Next, let’s evaluate the same KNN model as the previous section, but in this case on a normal quantile transform of the dataset.<\/p>\n
The complete example is listed below.<\/p>\n
# evaluate knn on the sonar dataset with normal quantile transform\r\nfrom numpy import mean\r\nfrom numpy import std\r\nfrom pandas import read_csv\r\nfrom sklearn.model_selection import cross_val_score\r\nfrom sklearn.model_selection import RepeatedStratifiedKFold\r\nfrom sklearn.neighbors import KNeighborsClassifier\r\nfrom sklearn.preprocessing import LabelEncoder\r\nfrom sklearn.preprocessing import QuantileTransformer\r\nfrom sklearn.pipeline import Pipeline\r\nfrom matplotlib import pyplot\r\n# load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/sonar.csv\"\r\ndataset = read_csv(url, header=None)\r\ndata = dataset.values\r\n# separate into input and output columns\r\nX, y = data[:, :-1], data[:, -1]\r\n# ensure inputs are floats and output is an integer label\r\nX = X.astype('float32')\r\ny = LabelEncoder().fit_transform(y.astype('str'))\r\n# define the pipeline\r\ntrans = QuantileTransformer(n_quantiles=100, output_distribution='normal')\r\nmodel = KNeighborsClassifier()\r\npipeline = Pipeline(steps=[('t', trans), ('m', model)])\r\n# evaluate the pipeline\r\ncv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)\r\nn_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')\r\n# report pipeline performance\r\nprint('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))<\/pre>\nRunning the example, we can see that the normal quantile transform results in a lift in performance from 79.7% accuracy without the transform to about 81.7% with the transform.<\/p>\n
Accuracy: 0.817 (0.087)<\/pre>\n
Next, let’s take a closer look at the uniform quantile transform.<\/p>\n
Uniform Quantile Transform<\/h2>\n
Sometimes it can be beneficial to transform a highly exponential or multi-modal distribution to have a uniform distribution.<\/p>\n
This is especially useful for data with a large and sparse range of values, e.g. outliers that are common rather than rare.<\/p>\n
We can apply the transform by defining a QuantileTransformer<\/em> class and setting the “output_distribution<\/em>” argument to “uniform<\/em>” (the default).<\/p>\n
...\r\n# perform a uniform quantile transform of the dataset\r\ntrans = QuantileTransformer(n_quantiles=100, output_distribution='uniform')\r\ndata = trans.fit_transform(data)<\/pre>\n
The example below applies the uniform quantile transform and creates histogram plots of each of the transformed variables.<\/p>\n
# visualize a uniform quantile transform of the sonar dataset\r\nfrom pandas import read_csv\r\nfrom pandas import DataFrame\r\nfrom pandas.plotting import scatter_matrix\r\nfrom sklearn.preprocessing import QuantileTransformer\r\nfrom matplotlib import pyplot\r\n# load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/sonar.csv\"\r\ndataset = read_csv(url, header=None)\r\n# retrieve just the numeric input values\r\ndata = dataset.values[:, :-1]\r\n# perform a uniform quantile transform of the dataset\r\ntrans = QuantileTransformer(n_quantiles=100, output_distribution='uniform')\r\ndata = trans.fit_transform(data)\r\n# convert the array back to a dataframe\r\ndataset = DataFrame(data)\r\n# histograms of the variables\r\ndataset.hist()\r\npyplot.show()<\/pre>\n
Running the example transforms the dataset and plots histograms of each input variable.<\/p>\n
We can see that the shape of the histograms for each variable looks very uniform compared to the raw data.<\/p>\n
![\"Histogram](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Histogram-Plots-of-Uniform-Quantile-Transformed-Input-Variables-for-the-Sonar-Dataset.png\")
<\/p>\nHistogram Plots of Uniform Quantile Transformed Input Variables for the Sonar Dataset<\/p>\n<\/div>\n
Next, let’s evaluate the same KNN model as the previous section, but in this case on a uniform quantile transform of the raw dataset.<\/p>\n
The complete example is listed below.<\/p>\n
# evaluate knn on the sonar dataset with uniform quantile transform\r\nfrom numpy import mean\r\nfrom numpy import std\r\nfrom pandas import read_csv\r\nfrom sklearn.model_selection import cross_val_score\r\nfrom sklearn.model_selection import RepeatedStratifiedKFold\r\nfrom sklearn.neighbors import KNeighborsClassifier\r\nfrom sklearn.preprocessing import LabelEncoder\r\nfrom sklearn.preprocessing import QuantileTransformer\r\nfrom sklearn.pipeline import Pipeline\r\nfrom matplotlib import pyplot\r\n# load dataset\r\nurl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/sonar.csv\"\r\ndataset = read_csv(url, header=None)\r\ndata = dataset.values\r\n# separate into input and output columns\r\nX, y = data[:, :-1], data[:, -1]\r\n# ensure inputs are floats and output is an integer label\r\nX = X.astype('float32')\r\ny = LabelEncoder().fit_transform(y.astype('str'))\r\n# define the pipeline\r\ntrans = QuantileTransformer(n_quantiles=100, output_distribution='uniform')\r\nmodel = KNeighborsClassifier()\r\npipeline = Pipeline(steps=[('t', trans), ('m', model)])\r\n# evaluate the pipeline\r\ncv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)\r\nn_scores = cross_val_score(pipeline, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')\r\n# report pipeline performance\r\nprint('Accuracy: %.3f (%.3f)' % (mean(n_scores), std(n_scores)))<\/pre>\nRunning the example, we can see that the uniform transform results in a lift in performance from 79.7 percent accuracy without the transform to about 84.5 percent with the transform, better than the normal transform that achieved a score of 81.7 percent.<\/p>\n
Accuracy: 0.845 (0.074)<\/pre>\n
We chose the number of quantiles as an arbitrary number, in this case, 100.<\/p>\n
This hyperparameter can be tuned to explore the effect of the resolution of the transform on the resulting skill of the model.<\/p>\n
The example below performs this experiment and plots the mean accuracy for different “n_quantiles<\/em>” values from 1 to 99.<\/p>\n
# explore number of quantiles on classification accuracy\r\nfrom numpy import mean\r\nfrom numpy import std\r\nfrom pandas import read_csv\r\nfrom sklearn.model_selection import cross_val_score\r\nfrom sklearn.model_selection import RepeatedStratifiedKFold\r\nfrom sklearn.neighbors import KNeighborsClassifier\r\nfrom sklearn.preprocessing import QuantileTransformer\r\nfrom sklearn.preprocessing import LabelEncoder\r\nfrom sklearn.pipeline import Pipeline\r\nfrom matplotlib import pyplot\r\n\r\n# get the dataset\r\ndef get_dataset():\r\n\t# load dataset\r\n\turl = \"https:\/\/raw.githubusercontent.com\/jbrownlee\/Datasets\/master\/sonar.csv\"\r\n\tdataset = read_csv(url, header=None)\r\n\tdata = dataset.values\r\n\t# separate into input and output columns\r\n\tX, y = data[:, :-1], data[:, -1]\r\n\t# ensure inputs are floats and output is an integer label\r\n\tX = X.astype('float32')\r\n\ty = LabelEncoder().fit_transform(y.astype('str'))\r\n\treturn X, y\r\n\r\n# get a list of models to evaluate\r\ndef get_models():\r\n\tmodels = dict()\r\n\tfor i in range(1,100):\r\n\t\t# define the pipeline\r\n\t\ttrans = QuantileTransformer(n_quantiles=i, output_distribution='uniform')\r\n\t\tmodel = KNeighborsClassifier()\r\n\t\tmodels[str(i)] = Pipeline(steps=[('t', trans), ('m', model)])\r\n\treturn models\r\n\r\n# evaluate a give model using cross-validation\r\ndef evaluate_model(model):\r\n\tcv = RepeatedStratifiedKFold(n_splits=10, n_repeats=3, random_state=1)\r\n\tscores = cross_val_score(model, X, y, scoring='accuracy', cv=cv, n_jobs=-1, error_score='raise')\r\n\treturn scores\r\n\r\n# define dataset\r\nX, y = get_dataset()\r\n# get the models to evaluate\r\nmodels = get_models()\r\n# evaluate the models and store results\r\nresults = list()\r\nfor name, model in models.items():\r\n\tscores = evaluate_model(model)\r\n\tresults.append(mean(scores))\r\n\tprint('>%s %.3f (%.3f)' % (name, mean(scores), std(scores)))\r\n# plot model performance for comparison\r\npyplot.plot(results)\r\npyplot.show()<\/pre>\nRunning the example reports the mean classification accuracy for each value of the “n_quantiles<\/em>” argument.<\/p>\n
We can see that surprisingly smaller values resulted in better accuracy, with values such as 4 achieving an accuracy of about 85.4 percent.<\/p>\n
>1 0.466 (0.016)\r\n>2 0.813 (0.085)\r\n>3 0.840 (0.080)\r\n>4 0.854 (0.075)\r\n>5 0.848 (0.072)\r\n>6 0.851 (0.071)\r\n>7 0.845 (0.071)\r\n>8 0.848 (0.066)\r\n>9 0.848 (0.071)\r\n>10 0.843 (0.074)\r\n...<\/pre>\n
A line plot is created showing the number of quantiles used in the transform versus the classification accuracy of the resulting model.<\/p>\n
We can see a bump with values less than 10 and drop and flat performance after that.<\/p>\n
The results highlight that there is likely some benefit in exploring different distributions and number of quantiles to see if better performance can be achieved.<\/p>\n
![\"Line](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Line-Plot-of-Number-of-Quantiles-vs-Classification-Accuracy-of-KNN-on-the-Sonar-Dataset.png\")
<\/p>\nLine Plot of Number of Quantiles vs. Classification Accuracy of KNN on the Sonar Dataset<\/p>\n<\/div>\n
Further Reading<\/h2>\n
This section provides more resources on the topic if you are looking to go deeper.<\/p>\n
Tutorials<\/h3>\n
- \n
- Continuous Probability Distributions for Machine Learning<\/a><\/li>\n
- How to Transform Target Variables for Regression With Scikit-Learn<\/a><\/li>\n<\/ul>\n
Dataset<\/h3>\n
- \n
- Sonar Dataset<\/a><\/li>\n
- Sonar Dataset Description<\/a><\/li>\n<\/ul>\n
APIs<\/h3>\n
- \n
- Non-linear transformation, scikit-learn Guide<\/a>.<\/li>\n
- sklearn.preprocessing.QuantileTransformer API<\/a>.<\/li>\n<\/ul>\n
Articles<\/h3>\n
- \n
- Quantile function, Wikipedia<\/a>.<\/li>\n<\/ul>\n
Summary<\/h2>\n
In this tutorial, you discovered how to use quantile transforms to change the distribution of numeric variables for machine learning.<\/p>\n
Specifically, you learned:<\/p>\n
- \n
- Many machine learning algorithms prefer or perform better when numerical variables have a Gaussian or standard probability distribution.<\/li>\n
- Quantile transforms are a technique for transforming numerical input or output variables to have a Gaussian or uniform probability distribution.<\/li>\n
- How to use the QuantileTransformer to change the probability distribution of numeric variables to improve the performance of predictive models.<\/li>\n<\/ul>\n
Do you have any questions?<\/strong>
\nAsk your questions in the comments below and I will do my best to answer.<\/p>\nThe post How to Use Quantile Transforms for Machine Learning<\/a> appeared first on Machine Learning Mastery<\/a>.<\/p>\n<\/div>\n
Go to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
- sklearn.preprocessing.QuantileTransformer API<\/a>.<\/li>\n<\/ul>\n
- Sonar Dataset Description<\/a><\/li>\n<\/ul>\n
- How to Transform Target Variables for Regression With Scikit-Learn<\/a><\/li>\n<\/ul>\n
- Sonar Dataset Description<\/a><\/li>\n<\/ul>\n
- Sonar Dataset<\/a><\/li>\n
- Continuous Probability Distributions for Machine Learning<\/a><\/li>\n<\/ul>\n