How I Automated My Machine Learning Workflow with Just 10 Lines of Python

is magical — until you’re stuck trying to come to a decision which model to make use of in your dataset. Do you have to go along with a random forest or logistic regression? What if a naïve Bayes model outperforms each? For many of us, answering which means hours of manual testing, model constructing, and confusion.

But what if you happen to could automate your entire model selection process?
In this text, I’ll walk you thru an easy but powerful Python automation that selects the most effective machine learning models in your dataset robotically. You don’t need deep ML knowledge or tuning skills. Just plug in your data and let Python do the remaining.

Why Automate ML Model Selection?

There are multiple reasons, let’s see a few of them. Give it some thought:

• Most datasets might be modeled in multiple ways.
• Trying each model manually is time-consuming.
• Picking the flawed model early can derail your project.

Automation lets you:

• Compare dozens of models immediately.
• Get performance metrics without writing repetitive code.
• Discover top-performing algorithms based on accuracy, F1 rating, or RMSE.

It’s not only convenient, it’s smart ML hygiene.

Libraries We Will Use

We might be exploring 2 underrated Python ML Automation libraries. These are lazypredict and pycaret. You may install each of those using the pip command given below.

pip install lazypredict
pip install pycaret

Importing Required Libraries

Now that we now have installed the required libraries, let’s import them. We can even import another libraries that can help us load the information and prepare it for modelling. We are able to import them using the code given below.

import pandas as pd
from sklearn.model_selection import train_test_split
from lazypredict.Supervised import LazyClassifier
from pycaret.classification import *

Loading Dataset

We might be using the diabetes dataset that’s freely available, and you possibly can take a look at this data from this link. We are going to use the command below to download the information, store it in a dataframe, and define the X(Features) and Y(End result).

# Load dataset
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
df = pd.read_csv(url, header=None)

X = df.iloc[:, :-1]
y = df.iloc[:, -1]

Using LazyPredict

Now that we now have the dataset loaded and the required libraries imported, let’s split the information right into a training and a testing dataset. After that, we’ll finally pass it to lazypredict to grasp which is the most effective model for our data.

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# LazyClassifier
clf = LazyClassifier(verbose=0, ignore_warnings=True)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)

# Top 5 models
print(models.head(5))

Within the output, we are able to clearly see that LazyPredict tried fitting the information in 20+ ML Models, and the performance when it comes to Accuracy, ROC, AUC, etc. is shown to pick the most effective model for the information. This makes the choice less time-consuming and more accurate. Similarly, we are able to create a plot of the accuracy of those models to make it a more visual decision. You may also check the time taken which is negligible which makes it far more time saving.

import matplotlib.pyplot as plt

# Assuming `models` is the LazyPredict DataFrame
top_models = models.sort_values("Accuracy", ascending=False).head(10)

plt.figure(figsize=(10, 6))
top_models["Accuracy"].plot(kind="barh", color="skyblue")
plt.xlabel("Accuracy")
plt.title("Top 10 Models by Accuracy (LazyPredict)")
plt.gca().invert_yaxis()
plt.tight_layout()

Using PyCaret

Now let’s check how PyCaret works. We are going to use the identical dataset to create the models and compare performance. We are going to use your entire dataset as PyCaret itself does a test-train split.

The code below will:

• Run 15+ models
• Evaluate them with cross-validation
• Return the most effective one based on performance

All in two lines of code.

clf = setup(data=df, goal=df.columns[-1])
best_model = compare_models()

As we are able to see here, PyCaret provides far more information in regards to the model’s performance. It could take a number of seconds greater than LazyPredict, nevertheless it also provides more information, in order that we are able to make an informed decision about which model we would like to go ahead with.

Real-Life Use Cases

Some real-life use cases where these libraries might be useful are:

• Rapid prototyping in hackathons
• Internal dashboards that suggest the most effective model for analysts
• Teaching ML without drowning in syntax
• Pre-testing ideas before full-scale deployment

Conclusion

Using AutoML libraries just like the ones we discussed doesn’t mean it is best to skip learning the mathematics behind models. But in a fast-paced world, it’s an enormous productivity boost.

What I really like about lazypredict and pycaret is that they provide you with a fast feedback loop, so you possibly can deal with feature engineering, domain knowledge, and interpretation.

In case you’re starting a brand new ML project, do this workflow. You’ll save time, make higher decisions, and impress your team. Let Python do the heavy lifting whilst you construct smarter solutions.