Many machine learning algorithms perform better when numerical input variables are scaled to a standard range.<\/p>\n
This includes algorithms that use a weighted sum of the input, like linear regression, and algorithms that use distance measures, like k-nearest neighbors.<\/p>\n
The two most popular techniques for scaling numerical data prior to modeling are normalization and standardization. Normalization<\/strong> scales each input variable separately to the range 0-1, which is the range for floating-point values where we have the most precision. Standardization<\/strong> scales each input variable separately by subtracting the mean (called centering) and dividing by the standard deviation to shift the distribution to have a mean of zero and a standard deviation of one.<\/p>\n In this tutorial, you will discover how to use scaler transforms to standardize and normalize numerical input variables for classification and regression.<\/p>\n After completing this tutorial, you will know:<\/p>\n Let’s get started.<\/p>\n How to Use StandardScaler and MinMaxScaler Transforms This tutorial is divided into six parts; they are:<\/p>\n Machine learning models learn a mapping from input variables to an output variable.<\/p>\n As such, the scale and distribution of the data drawn from the domain may be different for each variable.<\/p>\n Input variables may have different units (e.g. feet, kilometers, and hours) that, in turn, may mean the variables have different scales.<\/p>\n Differences in the scales across input variables may increase the difficulty of the problem being modeled. An example of this is that large input values (e.g. a spread of hundreds or thousands of units) can result in a model that learns large weight values. A model with large weight values is often unstable, meaning that it may suffer from poor performance during learning and sensitivity to input values resulting in higher generalization error.<\/p>\n One of the most common forms of pre-processing consists of a simple linear rescaling of the input variables.<\/p>\n<\/blockquote>\n — Page 298, Neural Networks for Pattern Recognition<\/a>, 1995.<\/p>\n This difference in scale for input variables does not affect all machine learning algorithms.<\/p>\n For example, algorithms that fit a model that use a weighted sum of input variables are affected, such as linear regression, logistic regression, and artificial neural networks (deep learning).<\/p>\n For example, when the distance or dot products between predictors are used (such as K-nearest neighbors or support vector machines) or when the variables are required to be a common scale in order to apply a penalty, a standardization procedure is essential.<\/p>\n<\/blockquote>\n — Page 124, Feature Engineering and Selection<\/a>, 2019.<\/p>\n Also, algorithms that use distance measures between examples or exemplars are affected, such as k-nearest neighbors and support vector machines. There are also algorithms that are unaffected by the scale of numerical input variables, most notably decision trees and ensembles of trees, like random forest.<\/p>\n Different attributes are measured on different scales, so if the Euclidean distance formula were used directly, the effect of some attributes might be completely dwarfed by others that had larger scales of measurement. Consequently, it is usual to normalize all attribute values …<\/p>\n<\/blockquote>\n — Page 145, Data Mining: Practical Machine Learning Tools and Techniques<\/a>, 2016.<\/p>\n It can also be a good idea to scale the target variable for regression predictive modeling problems to make the problem easier to learn, most notably in the case of neural network models. A target variable with a large spread of values, in turn, may result in large error gradient values causing weight values to change dramatically, making the learning process unstable.<\/p>\n Scaling input and output variables is a critical step in using neural network models.<\/p>\n In practice, it is nearly always advantageous to apply pre-processing transformations to the input data before it is presented to a network. Similarly, the outputs of the network are often post-processed to give the required output values.<\/p>\n<\/blockquote>\n — Page 296, Neural Networks for Pattern Recognition<\/a>, 1995.<\/p>\n Both normalization and standardization can be achieved using the scikit-learn library.<\/p>\n Let’s take a closer look at each in turn.<\/p>\n Normalization is a rescaling of the data from the original range so that all values are within the new range of 0 and 1.<\/p>\n Normalization requires that you know or are able to accurately estimate the minimum and maximum observable values. You may be able to estimate these values from your available data.<\/p>\n Attributes are often normalized to lie in a fixed range — usually from zero to one—by dividing all values by the maximum value encountered or by subtracting the minimum value and dividing by the range between the maximum and minimum values.<\/p>\n<\/blockquote>\n — Page 61, Data Mining: Practical Machine Learning Tools and Techniques<\/a>, 2016.<\/p>\n A value is normalized as follows:<\/p>\n Where the minimum and maximum values pertain to the value x being normalized.<\/p>\n For example, for a dataset, we could guesstimate the min and max observable values as 30 and -10. We can then normalize any value, like 18.8, as follows:<\/p>\n You can see that if an x value is provided that is outside the bounds of the minimum and maximum values, the resulting value will not be in the range of 0 and 1. You could check for these observations prior to making predictions and either remove them from the dataset or limit them to the pre-defined maximum or minimum values.<\/p>\n You can normalize your dataset using the scikit-learn object MinMaxScaler<\/a>.<\/p>\n Good practice usage with the MinMaxScaler and other scaling techniques is as follows:<\/p>\n The default scale for the MinMaxScaler<\/em> is to rescale variables into the range [0,1], although a preferred scale can be specified via the “feature_range<\/em>” argument and specify a tuple, including the min and the max for all variables.<\/p>\n We can demonstrate the usage of this class by converting two variables to a range 0-to-1, the default range for normalization. The first variable has values between about 4 and 100, the second has values between about 0.1 and 0.001.<\/p>\n The complete example is listed below.<\/p>\n Running the example first reports the raw dataset, showing 2 columns with 4 rows. The values are in scientific notation which can be hard to read if you’re not used to it.<\/p>\n Next, the scaler is defined, fit on the whole dataset and then used to create a transformed version of the dataset with each column normalized independently. We can see that the largest raw value for each column now has the value 1.0 and the smallest value for each column now has the value 0.0.<\/p>\n Now that we are familiar with normalization, let’s take a closer look at standardization.<\/p>\n Standardizing a dataset involves rescaling the distribution of values so that the mean of observed values is 0 and the standard deviation is 1.<\/p>\n This can be thought of as subtracting the mean value or centering the data.<\/p>\n Like normalization, standardization can be useful, and even required in some machine learning algorithms when your data has input values with differing scales.<\/p>\n Standardization assumes that your observations fit a Gaussian distribution<\/a> (bell curve) with a well-behaved mean and standard deviation. You can still standardize your data if this expectation is not met, but you may not get reliable results.<\/p>\n Another […] technique is to calculate the statistical mean and standard deviation of the attribute values, subtract the mean from each value, and divide the result by the standard deviation. This process is called standardizing a statistical variable and results in a set of values whose mean is zero and standard deviation is one.<\/p>\n<\/blockquote>\n — Page 61, Data Mining: Practical Machine Learning Tools and Techniques<\/a>, 2016.<\/p>\n Standardization requires that you know or are able to accurately estimate the mean and standard deviation of observable values. You may be able to estimate these values from your training data, not the entire dataset.<\/p>\n Again, it is emphasized that the statistics required for the transformation (e.g., the mean) are estimated from the training set and are applied to all data sets (e.g., the test set or new samples).<\/p>\n<\/blockquote>\n — Page 124, Feature Engineering and Selection<\/a>, 2019.<\/p>\n Subtracting the mean from the data is called centering<\/strong>, whereas dividing by the standard deviation is called scaling<\/strong>. As such, the method is sometime called “center scaling<\/strong>“.<\/p>\n The most straightforward and common data transformation is to center scale the predictor variables. To center a predictor variable, the average predictor value is subtracted from all the values. As a result of centering, the predictor has a zero mean. Similarly, to scale the data, each value of the predictor variable is divided by its standard deviation. Scaling the data coerce the values to have a common standard deviation of one.<\/p>\n<\/blockquote>\n — Page 30, Applied Predictive Modeling<\/a>, 2013.<\/p>\n A value is standardized as follows:<\/p>\n Where the mean<\/em> is calculated as:<\/p>\n And the standard_deviation<\/em> is calculated as:<\/p>\n We can guesstimate a mean of 10.0 and a standard deviation of about 5.0. Using these values, we can standardize the first value of 20.7 as follows:<\/p>\n The mean and standard deviation estimates of a dataset can be more robust to new data than the minimum and maximum.<\/p>\n You can standardize your dataset using the scikit-learn object StandardScaler<\/a>.<\/p>\n We can demonstrate the usage of this class by converting two variables to a range 0-to-1 defined in the previous section. We will use the default configuration that will both center and scale the values in each column, e.g. full standardization.<\/p>\n The complete example is listed below.<\/p>\n Running the example first reports the raw dataset, showing 2 columns with 4 rows as before.<\/p>\n Next, the scaler is defined, fit on the whole dataset and then used to create a transformed version of the dataset with each column standardized independently. We can see that the mean value in each column is assigned a value of 0.0 if present and the values are centered around 0.0 with values both positive and negative.<\/p>\n Next, we can introduce a real dataset that provides the basis for applying normalization and standardization transforms as a part of modeling.<\/p>\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<\/a>. Top performance 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 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 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 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 scaler transforms as the variables have differing minimum and maximum values, as well as different data distributions.<\/p>\n Histogram 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. The complete example is listed below.<\/p>\n Running 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 Next, let’s explore a scaling transform of the dataset.<\/p>\n We can apply the MinMaxScaler<\/em> to the Sonar dataset directly to normalize the input variables.<\/p>\n We will use the default configuration and scale values to the range 0 and 1. First, a MinMaxScaler<\/em> instance is defined with default hyperparameters. Once defined, we can call the fit_transform()<\/em> function and pass it to our dataset to create a transformed version of our dataset.<\/p>\n Let’s try it on our sonar dataset.<\/p>\n The complete example of creating a MinMaxScaler<\/em> transform of the sonar dataset and plotting histograms of the result is listed below.<\/p>\n Running the example first reports a summary of each input variable.<\/p>\n We can see that the distributions have been adjusted and that the minimum and maximum values for each variable are now a crisp 0.0 and 1.0 respectively.<\/p>\n Histogram plots of the variables are created, although the distributions don’t look much different from their original distributions seen in the previous section.<\/p>\n Histogram Plots of MinMaxScaler 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 MinMaxScaler<\/em> transform of the dataset.<\/p>\n The complete example is listed below.<\/p>\n Running the example, we can see that the MinMaxScaler transform results in a lift in performance from 79.7 percent accuracy without the transform to about 81.3 percent with the transform.<\/p>\n Next, let’s explore the effect of standardizing the input variables.<\/p>\n We can apply the StandardScaler<\/em> to the Sonar dataset directly to standardize the input variables.<\/p>\n We will use the default configuration and scale values to subtract the mean to center them on 0.0 and divide by the standard deviation to give the standard deviation of 1.0. First, a StandardScaler<\/em> instance is defined with default hyperparameters.<\/p>\n Once defined, we can call the fit_transform()<\/em> function and pass it to our dataset to create a transformed version of our dataset.<\/p>\n Let’s try it on our sonar dataset.<\/p>\n The complete example of creating a StandardScaler<\/em> transform of the sonar dataset and plotting histograms of the results is listed below.<\/p>\n Running the example first reports a summary of each input variable.<\/p>\n We can see that the distributions have been adjusted and that the mean is a very small number close to zero and the standard deviation is very close to 1.0 for each variable.<\/p>\n Histogram plots of the variables are created, although the distributions don’t look much different from their original distributions seen in the previous section other than their scale on the x-axis.<\/p>\n Histogram Plots of StandardScaler 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 StandardScaler transform of the dataset.<\/p>\n The complete example is listed below.<\/p>\n Running the example, we can see that the StandardScaler<\/em> transform results in a lift in performance from 79.7 percent accuracy without the transform to about 81.0 percent with the transform, although slightly lower than the result using the MinMaxScaler<\/em>.<\/p>\n This section lists some common questions and answers when scaling numerical data.<\/p>\n Whether input variables require scaling depends on the specifics of your problem and of each variable.<\/p>\n You may have a sequence of quantities as inputs, such as prices or temperatures.<\/p>\n If the distribution of the quantity is normal, then it should be standardized, otherwise, the data should be normalized. This applies if the range of quantity values is large (10s, 100s, etc.) or small (0.01, 0.0001).<\/p>\n If the quantity values are small (near 0-1) and the distribution is limited (e.g. standard deviation near 1), then perhaps you can get away with no scaling of the data.<\/p>\n These manipulations are generally used to improve the numerical stability of some calculations. Some models […] benefit from the predictors being on a common scale.<\/p>\n<\/blockquote>\n — Pages 30-31, Applied Predictive Modeling<\/a>, 2013.<\/p>\n Predictive modeling problems can be complex, and it may not be clear how to best scale input data.<\/p>\n If in doubt, normalize the input sequence. If you have the resources, explore modeling with the raw data, standardized data, and normalized data and see if there is a beneficial difference in the performance of the resulting model.<\/p>\n If the input variables are combined linearly, as in an MLP [Multilayer Perceptron], then it is rarely strictly necessary to standardize the inputs, at least in theory. […] However, there are a variety of practical reasons why standardizing the inputs can make training faster and reduce the chances of getting stuck in local optima.<\/p>\n<\/blockquote>\n — Should I normalize\/standardize\/rescale the data? Neural Nets FAQ<\/a><\/p>\n Standardization can give values that are both positive and negative centered around zero.<\/p>\n It may be desirable to normalize data after it has been standardized.<\/p>\n This might be a good idea of you have a mixture of standardized and normalized variables and wish all input variables to have the same minimum and maximum values as input for a given algorithm, such as an algorithm that calculates distance measures.<\/p>\n This is unknowable.<\/p>\n Evaluate models on data prepared with each transform and use the transform or combination of transforms that result in the best performance for your data set on your model.<\/p>\n You may normalize your data by calculating the minimum and maximum on the training data.<\/p>\n Later, you may have new data with values smaller or larger than the minimum or maximum respectively.<\/p>\n One simple approach to handling this may be to check for such out-of-bound values and change their values to the known minimum or maximum prior to scaling. Alternately, you may want to estimate the minimum and maximum values used in the normalization manually based on domain knowledge.<\/p>\n This section provides more resources on the topic if you are looking to go deeper.<\/p>\n In this tutorial, you discovered how to use scaler transforms to standardize and normalize numerical input variables for classification and regression.<\/p>\n Specifically, you learned:<\/p>\n Do you have any questions?<\/strong> The post How to Use StandardScaler and MinMaxScaler Transforms in Python<\/a> appeared first on Machine Learning Mastery<\/a>.<\/p>\n<\/div>\n Go to Source<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"\n
![\"How](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/08\/How-to-Use-StandardScaler-and-MinMaxScaler-Transforms.jpg\")
<\/p>\n
Photo by Marco Verch<\/a>, some rights reserved.<\/p>\n<\/div>\nTutorial Overview<\/h2>\n
\n
\n
The Scale of Your Data Matters<\/h2>\n
\n
\n
\n
\n
Numerical Data Scaling Methods<\/h2>\n
Data Normalization<\/h3>\n
\n
\n
\n
\n
# example of a normalization\r\nfrom numpy import asarray\r\nfrom sklearn.preprocessing import MinMaxScaler\r\n# define data\r\ndata = asarray([[100, 0.001],\r\n\t\t\t\t[8, 0.05],\r\n\t\t\t\t[50, 0.005],\r\n\t\t\t\t[88, 0.07],\r\n\t\t\t\t[4, 0.1]])\r\nprint(data)\r\n# define min max scaler\r\nscaler = MinMaxScaler()\r\n# transform data\r\nscaled = scaler.fit_transform(data)\r\nprint(scaled)<\/pre>\n
[[1.0e+02 1.0e-03]\r\n [8.0e+00 5.0e-02]\r\n [5.0e+01 5.0e-03]\r\n [8.8e+01 7.0e-02]\r\n [4.0e+00 1.0e-01]]\r\n[[1. 0. ]\r\n [0.04166667 0.49494949]\r\n [0.47916667 0.04040404]\r\n [0.875 0.6969697 ]\r\n [0. 1. ]]<\/pre>\n
Data Standardization<\/h3>\n
\n
\n
\n
\n
\n
\n
\n
# example of a standardization\r\nfrom numpy import asarray\r\nfrom sklearn.preprocessing import StandardScaler\r\n# define data\r\ndata = asarray([[100, 0.001],\r\n\t\t\t\t[8, 0.05],\r\n\t\t\t\t[50, 0.005],\r\n\t\t\t\t[88, 0.07],\r\n\t\t\t\t[4, 0.1]])\r\nprint(data)\r\n# define standard scaler\r\nscaler = StandardScaler()\r\n# transform data\r\nscaled = scaler.fit_transform(data)\r\nprint(scaled)<\/pre>\n
[[1.0e+02 1.0e-03]\r\n [8.0e+00 5.0e-02]\r\n [5.0e+01 5.0e-03]\r\n [8.8e+01 7.0e-02]\r\n [4.0e+00 1.0e-01]]\r\n[[ 1.26398112 -1.16389967]\r\n [-1.06174414 0.12639634]\r\n [ 0. -1.05856939]\r\n [ 0.96062565 0.65304778]\r\n [-1.16286263 1.44302493]]<\/pre>\n
Sonar Dataset<\/h2>\n
\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
(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
![\"Histogram](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Histogram-Plots-of-Input-Variables-for-the-Sonar-Binary-Classification-Dataset-1.png\")
<\/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>\nAccuracy: 0.797 (0.073)<\/pre>\n
MinMaxScaler Transform<\/h2>\n
...\r\n# perform a robust scaler transform of the dataset\r\ntrans = MinMaxScaler()\r\ndata = trans.fit_transform(data)<\/pre>\n
# visualize a minmax scaler 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 MinMaxScaler\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 robust scaler transform of the dataset\r\ntrans = MinMaxScaler()\r\ndata = trans.fit_transform(data)\r\n# convert the array back to a dataframe\r\ndataset = DataFrame(data)\r\n# summarize\r\nprint(dataset.describe())\r\n# histograms of the variables\r\ndataset.hist()\r\npyplot.show()<\/pre>\n
0 1 2 ... 57 58 59\r\ncount 208.000000 208.000000 208.000000 ... 208.000000 208.000000 208.000000\r\nmean 0.204011 0.162180 0.139068 ... 0.175035 0.216015 0.136425\r\nstd 0.169550 0.141277 0.126242 ... 0.148051 0.170286 0.116190\r\nmin 0.000000 0.000000 0.000000 ... 0.000000 0.000000 0.000000\r\n25% 0.087389 0.067938 0.057326 ... 0.075515 0.098485 0.057737\r\n50% 0.157080 0.129447 0.107753 ... 0.125858 0.173554 0.108545\r\n75% 0.251106 0.202958 0.185447 ... 0.229977 0.281680 0.183025\r\nmax 1.000000 1.000000 1.000000 ... 1.000000 1.000000 1.000000\r\n\r\n[8 rows x 60 columns]<\/pre>\n
![\"Histogram](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Histogram-Plots-of-MinMaxScaler-Transformed-Input-Variables-for-the-Sonar-Dataset.png\")
<\/p>\n# evaluate knn on the sonar dataset with minmax scaler 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 MinMaxScaler\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 = MinMaxScaler()\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>\nAccuracy: 0.813 (0.085)<\/pre>\n
StandardScaler Transform<\/h2>\n
...\r\n# perform a robust scaler transform of the dataset\r\ntrans = StandardScaler()\r\ndata = trans.fit_transform(data)<\/pre>\n
# visualize a standard scaler 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 StandardScaler\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 robust scaler transform of the dataset\r\ntrans = StandardScaler()\r\ndata = trans.fit_transform(data)\r\n# convert the array back to a dataframe\r\ndataset = DataFrame(data)\r\n# summarize\r\nprint(dataset.describe())\r\n# histograms of the variables\r\ndataset.hist()\r\npyplot.show()<\/pre>\n
0 1 ... 58 59\r\ncount 2.080000e+02 2.080000e+02 ... 2.080000e+02 2.080000e+02\r\nmean -4.190024e-17 1.663333e-16 ... 1.283695e-16 3.149190e-17\r\nstd 1.002413e+00 1.002413e+00 ... 1.002413e+00 1.002413e+00\r\nmin -1.206158e+00 -1.150725e+00 ... -1.271603e+00 -1.176985e+00\r\n25% -6.894939e-01 -6.686781e-01 ... -6.918580e-01 -6.788714e-01\r\n50% -2.774703e-01 -2.322506e-01 ... -2.499546e-01 -2.405314e-01\r\n75% 2.784345e-01 2.893335e-01 ... 3.865486e-01 4.020352e-01\r\nmax 4.706053e+00 5.944643e+00 ... 4.615037e+00 7.450343e+00\r\n\r\n[8 rows x 60 columns]<\/pre>\n
![\"Histogram](\"https:\/\/machinelearningmastery.com\/wp-content\/uploads\/2020\/05\/Histogram-Plots-of-StandardScaler-Transformed-Input-Variables-for-the-Sonar-Dataset.png\")
<\/p>\n# evaluate knn on the sonar dataset with standard scaler 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 StandardScaler\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 = StandardScaler()\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>\nAccuracy: 0.810 (0.080)<\/pre>\n<\/p>\n
Common Questions<\/h2>\n
Q. Should I Normalize or Standardize?<\/h4>\n
\n
\n
Q. Should I Standardize then Normalize?<\/h4>\n
Q. But Which is Best?<\/h4>\n
Q. How Do I Handle Out-of-Bounds Values?<\/h4>\n
Further Reading<\/h2>\n
Tutorials<\/h3>\n
\n
Books<\/h3>\n
\n
APIs<\/h3>\n
\n
Articles<\/h3>\n
\n
Summary<\/h2>\n
\n
\nAsk your questions in the comments below and I will do my best to answer.<\/p>\n