Use the offer code 20offearlybird to get 20% off. Hurry, sale ends soon!

# How to Develop a Framework to Spot-Check Machine Learning Algorithms in Python

Spot-checking algorithms is a technique in applied machine learning designed to quickly and objectively provide a first set of results on a new predictive modeling problem.

Unlike grid searching and other types of algorithm tuning that seek the optimal algorithm or optimal configuration for an algorithm, spot-checking is intended to evaluate a diverse set of algorithms rapidly and provide a rough first-cut result. This first cut result may be used to get an idea if a problem or problem representation is indeed predictable, and if so, the types of algorithms that may be worth investigating further for the problem.

Spot-checking is an approach to help overcome the “hard problem” of applied machine learning and encourage you to clearly think about the higher-order search problem being performed in any machine learning project.

In this tutorial, you will discover the usefulness of spot-checking algorithms on a new predictive modeling problem and how to develop a standard framework for spot-checking algorithms in python for classification and regression problems.

After completing this tutorial, you will know:

• Spot-checking provides a way to quickly discover the types of algorithms that perform well on your predictive modeling problem.
• How to develop a generic framework for loading data, defining models, evaluating models, and summarizing results.
• How to apply the framework for classification and regression problems.

Kick-start your project with my new book Machine Learning Mastery With Python, including step-by-step tutorials and the Python source code files for all examples.

Let’s get started.

How to Develop a Reusable Framework for Spot-Check Algorithms in Python
Photo by Jeff Turner, some rights reserved.

## Tutorial Overview

This tutorial is divided into five parts; they are:

1. Spot-Check Algorithms
2. Spot-Checking Framework in Python
3. Spot-Checking for Classification
4. Spot-Checking for Regression
5. Framework Extension

## 1. Spot-Check Algorithms

We cannot know beforehand what algorithms will perform well on a given predictive modeling problem.

This is the hard part of applied machine learning that can only be resolved via systematic experimentation.

Spot-checking is an approach to this problem.

It involves rapidly testing a large suite of diverse machine learning algorithms on a problem in order to quickly discover what algorithms might work and where to focus attention.

• It is fast; it by-passes the days or weeks of preparation and analysis and playing with algorithms that may not ever lead to a result.
• It is objective, allowing you to discover what might work well for a problem rather than going with what you used last time.
• It gets results; you will actually fit models, make predictions and know if your problem can be predicted and what baseline skill may look like.

Spot-checking may require that you work with a small sample of your dataset in order to turn around results quickly.

Finally, the results from spot checking are a jumping-off point. A starting point. They suggest where to focus attention on the problem, not what the best algorithm might be. The process is designed to shake you out of typical thinking and analysis and instead focus on results.

Now that we know what spot-checking is, let’s look at how we can systematically perform spot-checking in Python.

## 2. Spot-Checking Framework in Python

In this section we will build a framework for a script that can be used for spot-checking machine learning algorithms on a classification or regression problem.

There are four parts to the framework that we need to develop; they are:

• Define Models
• Evaluate Models
• Summarize Results

Let’s take a look at each in turn.

The first step of the framework is to load the data.

The function must be implemented for a given problem and be specialized to that problem. It will likely involve loading data from one or more CSV files.

We will call this function load_data(); it will take no arguments and return the inputs (X) and outputs (y) for the prediction problem.

### Define Models

The next step is to define the models to evaluate on the predictive modeling problem.

The models defined will be specific to the type predictive modeling problem, e.g. classification or regression.

The defined models should be diverse, including a mixture of:

• Linear Models.
• Nonlinear Models.
• Ensemble Models.

Each model should be a given a good chance to perform well on the problem. This might be mean providing a few variations of the model with different common or well known configurations that perform well on average.

We will call this function define_models(). It will return a dictionary of model names mapped to scikit-learn model object. The name should be short, like ‘svm‘ and may include a configuration detail, e.g. ‘knn-7’.

The function will also take a dictionary as an optional argument; if not provided, a new dictionary is created and populated. If a dictionary is provided, models are added to it.

This is to add flexibility if you would like to have multiple functions for defining models, or add a large number of models of a specific type with different configurations.

The idea is not to grid search model parameters; that can come later.

Instead, each model should be given an opportunity to perform well (i.e. not optimally). This might mean trying many combinations of parameters in some cases, e.g. in the case of gradient boosting.

### Evaluate Models

The next step is the evaluation of the defined models on the loaded dataset.

The scikit-learn library provides the ability to pipeline models during evaluation. This allows the data to be transformed prior to being used to fit a model, and this is done in a correct way such that the transforms are prepared on the training data and applied to the test data.

We can define a function that prepares a given model prior to evaluation to allow specific transforms to be used during the spot checking process. They will be performed in a blanket way to all models. This can be useful to perform operations such as standardization, normalization, and feature selection.

We will define a function named make_pipeline() that takes a defined model and returns a pipeline. Below is an example of preparing a pipeline that will first standardize the input data, then normalize it prior to fitting the model.

This function can be expanded to add other transforms, or simplified to return the provided model with no transforms.

Now we need to evaluate a prepared model.

We will use a standard of evaluating models using k-fold cross-validation. The evaluation of each defined model will result in a list of results. This is because 10 different versions of the model will have been fit and evaluated, resulting in a list of k scores.

We will define a function named evaluate_model() that will take the data, a defined model, a number of folds, and a performance metric used to evaluate the results. It will return the list of scores.

The function calls make_pipeline() for the defined model to prepare any data transforms required, then calls the cross_val_score() scikit-learn function. Importantly, the n_jobsÂ argument is set to -1 to allow the model evaluations to occur in parallel, harnessing as many cores as you have available on your hardware.

It is possible for the evaluation of a model to fail with an exception. I have seen this especially in the case of someÂ models from the statsmodels library.

It is also possible for the evaluation of a model to result in a lot of warning messages. I have seen this especially in the case of using XGBoost models.

We do not care about exceptions or warnings when spot checking. We only want to know what does work and what works well. Therefore, we can trap exceptions and ignore all warnings when evaluating each model.

The function named robust_evaluate_model() implements this behavior. The evaluate_model() is called in a way that traps exceptions and ignores warnings. If an exception occurs and no result was possible for a given model, a None result is returned.

Finally, we can define the top-level function for evaluating the list of defined models.

We will define a function named evaluate_models() that takes the dictionary of models as an argument and returns a dictionary of model names to lists of results.

The number of folds in the cross-validation process can be specified by an optional argument that defaults to 10. The metric calculated on the predictions from the model can also be specified by an optional argument and defaults to classification accuracy.

For a full list of supported metrics, see this list:

Any None results are skipped and not added to the dictionary of results.

Importantly, we provide some verbose output, summarizing the mean and standard deviation of each model after it was evaluated. This is helpful if the spot checking process on your dataset takes minutes to hours.

Note that if for some reason you want to see warnings and errors, you can update the evaluate_models() to call the evaluate_model() function directly, by-passing the robust error handling. I find this useful when testing out new methods or method configurations that fail silently.

### Summarize Results

Finally, we can evaluate the results.

Really, we only want to know what algorithms performed well.

Two useful ways to summarize the results are:

1. Line summaries of the mean and standard deviation of the top 10 performing algorithms.
2. Box and whisker plots of the top 10 performing algorithms.

The line summaries are quick and precise, although assume a well behaving Gaussian distribution, which may not be reasonable.

The box and whisker plots assume no distribution and provide a visual way to directly compare the distribution of scores across models in terms of median performance and spread of scores.

We will define a function named summarize_results() that takes the dictionary of results, prints the summary of results, and creates a boxplot image that is saved to file. The function takes an argument to specify if the evaluation score is maximizing, which by default is True. The number of results to summarize can also be provided as an optional parameter, which defaults to 10.

The function first orders the scores before printing the summary and creating the box and whisker plot.

Now that we have specialized a framework for spot-checking algorithms in Python, let’s look at how we can apply it to a classification problem.

## 3. Spot-Checking for Classification

We will generate a binary classification problem using the make_classification() function.

The function will generate 1,000 samples with 20 variables, with some redundant variables and two classes.

As a classification problem, we will try a suite of classification algorithms, specifically:

### Linear Algorithms

• Logistic Regression
• Ridge Regression
• Passive Aggressive Classifier

I tried LDA and QDA, but they sadly crashed down in the C-code somewhere.

### Nonlinear Algorithms

• k-Nearest Neighbors
• Classification and Regression Trees
• Extra Tree
• Support Vector Machine
• Naive Bayes

### Ensemble Algorithms

• Bagged Decision Trees
• Random Forest
• Extra Trees

Further, I added multiple configurations for a few of the algorithms like Ridge, kNN, and SVM in order to give them a good chance on the problem.

The full define_models() function is listed below.

That’s it; we are now ready to spot check algorithms on the problem.

The complete example is listed below.

Running the example prints one line per evaluated model, ending with a summary of the top 10 performing algorithms on the problem.

Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

We can see that ensembles of decision trees performed the best for this problem. This suggests a few things:

• Ensembles of decision trees might be a good place to focus attention.
• Gradient boosting will likely do well if further tuned.
• A “good” performance on the problem is about 86% accuracy.
• The relatively high performance of ridge regression suggests the need for feature selection.

A box and whisker plot is also created to summarize the results of the top 10 well performing algorithms.

The plot shows the elevation of the methods comprised of ensembles of decision trees. The plot enforces the notion that further attention on these methods would be a good idea.

Boxplot of top 10 Spot-Checking Algorithms on a Classification Problem

If this were a real classification problem, I would follow-up with further spot checks, such as:

• Spot check with various different feature selection methods.
• Spot check without data scaling methods.
• Spot check with a course grid of configurations for gradient boosting in sklearn or XGBoost.

Next, we will see how we can apply the framework to a regression problem.

## 4. Spot-Checking for Regression

We can explore the same framework for regression predictive modeling problems with only very minor changes.

We can use the make_regression() function to generate a contrived regression problem with 1,000 examples and 50 features, some of them redundant.

The defined load_dataset() function is listed below.

We can then specify a get_models() function that defines a suite of regression methods.

Scikit-learn does offer a wide range of linear regression methods, which is excellent. Not all of them may be required on your problem. I would recommend a minimum of linear regression and elastic net, the latter with a good suite of alpha and lambda parameters.

Nevertheless, we will test the full suite of methods on this problem, including:

### Linear Algorithms

• Linear Regression
• Lasso Regression
• Ridge Regression
• Elastic Net Regression
• Huber Regression
• LARS Regression
• Lasso LARS Regression
• Passive Aggressive Regression
• RANSAC Regressor
• Theil Regression

### Nonlinear Algorithms

• k-Nearest Neighbors
• Classification and Regression Tree
• Extra Tree
• Support Vector Regression

### Ensemble Algorithms

• Bagged Decision Trees
• Random Forest
• Extra Trees

The full get_models() function is listed below.

By default, the framework uses classification accuracy as the method for evaluating model predictions.

This does not make sense for regression, and we can change this something more meaningful for regression, such as mean squared error. We can do this by passing the metric=’neg_mean_squared_error’ argument when calling evaluate_models() function.

Note that by default scikit-learn inverts error scores so that that are maximizing instead of minimizing. This is why the mean squared error is negative and will have a negative sign when summarized. Because the score is inverted, we can continue to assume that we are maximizing scores in the summarize_results() function and do not need to specify maximize=False as we might expect when using an error metric.

The complete code example is listed below.

Running the example summarizes the performance of each model evaluated, then prints the performance of the top 10 well performing algorithms.

Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

We can see that many of the linear algorithms perhaps found the same optimal solution on this problem. Notably those methods that performed well use regularization as a type of feature selection, allowing them to zoom in on the optimal solution.

This would suggest the importance of feature selection when modeling this problem and that linear methods would be the area to focus, at least for now.

Reviewing the printed scores of evaluated models also shows how poorly nonlinear and ensemble algorithms performed on this problem.

A box and whisker plot is created, not really adding value to the analysis of results in this case.

Boxplot of top 10 Spot-Checking Algorithms on a Regression Problem

## 5. Framework Extension

In this section, we explore some handy extensions of the spot check framework.

### Course Grid Search for Gradient Boosting

I find myself using XGBoost and gradient boosting a lot for straight-forward classification and regression problems.

As such, I like to use a course grid across standard configuration parameters of the method when spot checking.

Below is a function to do this that can be used directly in the spot checking framework.

By default, the function will use XGBoost models, but can use the sklearn gradient boosting model if the use_xgb argument to the function is set to False.

Again, we are not trying to optimally tune GBM on the problem, only very quickly find an area in the configuration space that may be worth investigating further.

This function can be used directly on classification and regression problems with only a minor change from “XGBClassifier” to “XGBRegressor” and “GradientBoostingClassifier” to “GradientBoostingRegressor“. For example:

To make this concrete, below is the binary classification example updated to also define XGBoost models.

Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

Running the example shows that indeed some XGBoost models perform well on the problem.

Boxplot of top 10 Spot-Checking Algorithms on a Classification Problem with XGBoost

### Repeated Evaluations

The above results also highlight the noisy nature of the evaluations, e.g. the results of extra trees in this run are different from the run above (0.858 vs 0.869).

We are using k-fold cross-validation to produce a population of scores, but the population is small and the calculated mean will be noisy.

This is fine as long as we take the spot-check results as a starting point and not definitive results of an algorithm on the problem. This is hard to do; it takes discipline in the practitioner.

Alternately, you may want to adapt the framework such that the model evaluation scheme better matches the model evaluation scheme you intend to use for your specific problem.

For example, when evaluating stochastic algorithms like bagged or boosted decision trees, it is a good idea to run each experiment multiple times on the same train/test sets (called repeats) in order to account for the stochastic nature of the learning algorithm.

We can update the evaluate_model() function to repeat the evaluation of a given model n-times, with a different split of the data each time, then return all scores. For example, three repeats of 10-fold cross-validation will result in 30 scores from each to calculate a mean performance of a model.

Alternately, you may prefer to calculate a mean score from each k-fold cross-validation run, then calculate a grand mean of all runs, as described in:

We can then update the robust_evaluate_model() function to pass down the repeats argument and the evaluate_models() function to define a default, such as 3.

A complete example of the binary classification example with three repeats of model evaluation is listed below.

Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

Running the example produces a more robust estimate of the scores.

There will still be some variance in the reported means, but less than a single run of k-fold cross-validation.

The number of repeats may be increased to further reduce this variance, at the cost of longer run times, and perhaps against the intent of spot checking.

### Varied Input Representations

I am a big fan of avoiding assumptions and recommendations for data representations prior to fitting models.

Instead, I like to also spot-check multiple representations and transforms of input data, which I refer to as views. I explain this more in the post:

We can update the framework to spot-check multiple different representations for each model.

One way to do this is to update the evaluate_models() function so that we can provide a list of make_pipeline() functions that can be used for each defined model.

The chosen pipeline function can then be passed along down to the robust_evaluate_model() function and to the evaluate_model() function where it can be used.

We can then define a bunch of different pipeline functions; for example:

Then create a list of these function names that can be provided to the evaluate_models() function.

The complete example of the classification case updated to spot check pipeline transforms is listed below.

Running the example shows that we differentiate the results for each pipeline by adding the pipeline number to the beginning of the algorithm description name, e.g. ‘0rf‘ means RF with the first pipeline, which is no transforms.

Note: Your results may vary given the stochastic nature of the algorithm or evaluation procedure, or differences in numerical precision. Consider running the example a few times and compare the average outcome.

The ensembles of trees algorithms perform well on this problem, and these algorithms are invariant to data scaling. This means that their results on each pipeline will be similar (or the same) and in turn they will crowd out other algorithms in the top-10 list.

This section provides more resources on the topic if you are looking to go deeper.

## Summary

In this tutorial, you discovered the usefulness of spot-checking algorithms on a new predictive modeling problem and how to develop a standard framework for spot-checking algorithms in python for classification and regression problems.

Specifically, you learned:

• Spot-checking provides a way to quickly discover the types of algorithms that perform well on your predictive modeling problem.
• How to develop a generic framework for loading data, defining models, evaluating models, and summarizing results.
• How to apply the framework for classification and regression problems.

Have you used this framework or do you have some further suggestions to improve it?
Let me know in the comments.

Do you have any questions?

## Discover Fast Machine Learning in Python!

#### Develop Your Own Models in Minutes

...with just a few lines of scikit-learn code

Learn how in my new Ebook:
Machine Learning Mastery With Python

Covers self-study tutorials and end-to-end projects like:

### 28 Responses to How to Develop a Framework to Spot-Check Machine Learning Algorithms in Python

1. Chris wong September 14, 2018 at 11:03 am #

hi Jason,
have you tried using the autoML tools such as autoKeras & Auto-sklearn packages?
(I’ve also used AutoWeka in the weka package – very limited, and Rapidminer Auto-Modelling).

c

• Jason Brownlee September 14, 2018 at 2:35 pm #

I generally don’t use them. Have you?

2. Richard September 14, 2018 at 1:11 pm #

Is this possible in R?

• Jason Brownlee September 14, 2018 at 2:35 pm #

Yes, with the caret package.

I even have examples on the blog, search “spot check”.

3. Jurek September 14, 2018 at 4:01 pm #

This is truly one of the best resources for ML on the web

• Jason Brownlee September 15, 2018 at 6:01 am #

Thanks, I’m happy it helps.

4. Raj September 14, 2018 at 5:10 pm #

Hello Sir,

Awesome post on spot checking algorithm. This is really a great one – one stop shop!

I have couple of basic questions here –

1) How the similar approach along with pipeline can be applied to different Keras models -sequential, functional and KerasRegressor/KerasClassifier (with layers/dropouts/optimizers etc.)?

2) Do we need to reset states/layers in evaluate models prior to build/apply pipeline?

3) Post evaluation and finalizing the model, do we need to rebuild model, compile, fit to predict the test dataset or use the existing compiled model to fit and predict? Will predicted values/scores vary for each runs due to different weight initializations?

Thanking you in anticipation for your response.

• Jason Brownlee September 15, 2018 at 6:02 am #

Neural nets might be too big/slow for this type of framework and you may have to grid search manually.

Regardless of model, you should redefine and refit for each eval.

A finalized model is refit on all available data.

5. Rohit September 15, 2018 at 7:22 pm #

Hello sir this is the best article on spot checking algorithm , I have a little doubt about the Box and whisker plot.
Could you please explain what are the things the box plot is showing beside scores?

• Jason Brownlee September 16, 2018 at 5:58 am #

Thanks.

The boxplot summarizes the distribution of scores for each algorithm and allows simple comparison between the distributions.

6. Mansoor September 15, 2018 at 7:32 pm #

Good well rounded post.
Would really appreciate similar spot checking for (not too deep) neural nets framework in keras or tensorflow.

7. George September 25, 2018 at 5:45 am #

Great post. As always ðŸ™‚

8. Deva October 1, 2018 at 2:23 pm #

Great Article sir !! Sir consider creating you tube channel for you with all your contents!!.. It would help millions.

9. JG December 1, 2018 at 11:39 pm #

Very rich an complete post Jason!. I hope to have enough time to go through all the spot check algorithms included details !.Thanks

Anyway in a fast reading I appreciate this tip for hardware with many cores (as it is my case):

“Importantly, the n_jobs argument is set to -1 to allow the model evaluations to occur in parallel, harnessing as many cores as you have available on your hardware”.
scores = cross_val_score(pipeline, X, y, scoring=metric, cv=folds, n_jobs=-1)

Also I understand that these Spot Check techniques are applicable when the model fit is very short, because if not (as it is the case of big dataset, training, epochs, etc. or more complex models) …this a problem intractable by spot check

• Jason Brownlee December 2, 2018 at 6:20 am #

Thanks.

Yes, for large datasets there is benefit is using a small sample to ensure the process is timely.

10. Samaneh May 21, 2020 at 5:43 am #

Dear Jason,

My question is about the negative values of metrics such as MSE or neg_mean_squared_error.

How can we interpret a negative result?

11. John White August 25, 2020 at 11:13 am #

Hello Jason,

In your experience for practical examples, does spot-checking models usually result in low scores (.55) and then we’d have to work it up by applying machine learning techniques, like feature selection, importance, etc to get it up to an acceptable level? What are your thoughts on this? Thank you!

-John

• Jason Brownlee August 25, 2020 at 1:34 pm #

Good question.

It really depends on the specific dataset. Sometimes we can get good results immediately, sometimes we have to really work at it and tease out a good representation from the data.

12. Neto_89 September 10, 2020 at 8:37 am #

Great article!! Thanks Jason!!!

13. Bahar December 11, 2020 at 7:19 pm #

Thanks, like always very useful and applicable tutorial.
If we want to apply PCA should it be after the following code?

# normalization
steps.append((‘normalize’, MinMaxScaler()))

• Jason Brownlee December 12, 2020 at 6:24 am #

It is a good idea to use PCA after scaling, such as after a minmaxsclaer or after a standardscaler.

14. Edo January 25, 2022 at 10:25 pm #

Hi Jason, thanks for the great article.

I just wanted to flag a typo in the get_gb_models function for regression, you wrote GradientBoostingXGBRegressor instead of GradientBoostingRegressor.

Since I am here, in define_models you pass an empty dictionary as a default variable.
def define_models(models=dict()):
# …
return models
Not a big problem unless you call that function more than once. From the second time onwards the default value will be whatever models is at the end of the first call, and not an empty dictionary. Try to run this:
def asd(d=dict()):
print(d)
d[1] = 1
return d

• James Carmichael January 26, 2022 at 11:07 am #

Thank you for the feedback, Edo!