Machine Learning Using Python: A Practical Guide for Beginners

Machine Learning Using Python: A Practical Introduction

Machine learning is a way of teaching computers to identify patterns in data and use them to make predictions or decisions. It is used in applications ranging from email filtering and product recommendations to medical research and fraud detection.

Python is one of the most popular languages for machine learning. Its clear syntax and extensive collection of libraries make it suitable for beginners and experienced developers alike. This article introduces the basic workflow and shows how to build a simple machine-learning model.

What is machine learning?

In traditional programming, a developer writes explicit instructions for a computer to follow. In machine learning, a model is instead trained using examples. It learns patterns from those examples and applies what it has learnt to new data.

There are three broad types of machine learning:

Supervised learning: the model learns from examples that include the correct answers. It can be used to predict a category, such as whether an email is spam, or a numerical value, such as a house price.
Unsupervised learning: the model looks for patterns in data without being given labelled answers. One example is grouping customers with similar behaviours.
Reinforcement learning: the model learns by taking actions and receiving rewards or penalties, often in a simulated environment.

Why use Python?

Python’s machine-learning ecosystem offers tools for different stages of a project. pandas helps with working with tables of data, while NumPy supports numerical calculations. Matplotlib and seaborn are commonly used to visualise data. For machine learning itself, scikit-learn provides a consistent set of tools for preparing data, training models and assessing their performance.

A simple machine-learning workflow

Define the problem. Decide what you want the model to predict or discover.
Collect and inspect data. Check its size, format, quality and relevance.
Prepare the data. Handle missing values, convert categories into usable formats and choose relevant features.
Split the data. Keep some examples aside so you can test how well the model performs on data it has not seen before.
Train a model. Use the training data to let the algorithm learn patterns.
Evaluate the results. Choose measures that suit the task and examine whether the model is useful.
Improve and monitor it. Test alternatives and check performance when the model is used with new data.

Building a basic model with scikit-learn

The example below uses the Iris dataset, which contains measurements of iris flowers and their species. The task is to predict a flower’s species from its measurements. The dataset is included with scikit-learn, so no separate download is needed.

from sklearn.datasets import load_iris


from sklearn.model_selection import train_test_split


from sklearn.tree import DecisionTreeClassifier


from sklearn.metrics import accuracy_score





# Load the data


iris = load_iris()


X = iris.data


y = iris.target





# Set aside data for testing


X_train, X_test, y_train, y_test = train_test_split(


    X, y, test_size=0.2, random_state=42, stratify=y


)





# Create and train the model


model = DecisionTreeClassifier(random_state=42)


model.fit(X_train, y_train)





# Make predictions and measure accuracy


predictions = model.predict(X_test)


accuracy = accuracy_score(y_test, predictions)





print(f"Accuracy: {accuracy:.2f}")

Here, X contains the flower measurements, while y contains the species labels. The model learns from the training portion of the data. Its predictions are then compared with the known labels in the test portion. The random_state setting makes the split repeatable, while stratify=y helps preserve the balance of species in both sets.

Choosing the right evaluation measure

Accuracy is the proportion of predictions that are correct. It is useful for some problems, but it can be misleading when one category is much more common than another. For example, a model that labels every transaction as legitimate could appear highly accurate if fraudulent transactions are rare.

For classification tasks, other useful measures include precision, recall and the F1 score. For prediction of numerical values, measures such as mean absolute error or root mean squared error may be more appropriate. The best measure depends on the problem and the consequences of different kinds of mistakes.

Common challenges

Poor-quality data: missing, inconsistent or incorrectly labelled records can undermine results.
Overfitting: a model may learn the training examples too closely and perform poorly on new data.
Data leakage: information that would not be available at prediction time may accidentally influence training or evaluation, making results appear better than they really are.
Bias: data can reflect historical inequalities or gaps in representation. A model may reproduce or amplify them.
Unclear objectives: a technically accurate model is not necessarily useful if it does not address the real-world need.

Good practices for beginners

Start with a clear question and a simple baseline model. Keep test data separate from the training process, and use a validation approach such as cross-validation when comparing models. Document the data sources and decisions made during preparation. Consider privacy, fairness and the potential impact of automated decisions from the beginning, rather than treating them as an afterthought.

It is also important to remember that machine learning does not remove the need for human judgement. Predictions can be uncertain, and their limitations should be understood before they are used in important decisions.

Conclusion

Python makes it straightforward to explore machine learning, from inspecting a dataset to training and evaluating a model. Libraries such as scikit-learn provide accessible tools, but successful projects depend just as much on asking the right question, preparing reliable data and evaluating results carefully. A small, well-understood model is often the best place to begin.

9 Essential Tips for Mastering Machine Learning with Python

Start with a clear, measurable goal.
Clean and explore your data with pandas.
Split data into training and test sets.
Build a simple baseline before complex models.
Use scikit-learn pipelines to prevent data leakage.
Scale features when your model needs it.
Choose metrics that match your task.
Tune hyperparameters using cross-validation.
Set random seeds for reproducible results.

Start with a clear, measurable goal.

Before building a machine-learning model, define exactly what you want it to achieve and how success will be measured. A clear, measurable goal—such as reducing prediction error or correctly identifying a set proportion of fraudulent transactions—helps you choose suitable data, methods and evaluation metrics. It also makes it easier to tell whether the model is genuinely useful, rather than simply producing impressive-looking results.

Clean and explore your data with pandas.

Clean and explore your data with pandas before training a machine-learning model. Use it to inspect columns and data types, identify missing values and duplicates, and spot inconsistencies that could affect your results. Simple summaries and visualisations can reveal patterns, unusual values or imbalances in your data. Taking time to understand and prepare your dataset helps you choose suitable features and build a more reliable model.

Split data into training and test sets.

Split your data into separate training and test sets before building a machine-learning model. Use the training set to teach the model, then assess its performance on the test set, which it has not seen before. This gives a more realistic indication of how well the model may work with new data and helps reveal when it has simply memorised the examples it was given.

Build a simple baseline before complex models.

Start by building a simple baseline model before trying more complex approaches. A baseline gives you a clear point of comparison, helping you judge whether extra complexity genuinely improves performance. In Python, you might begin with a basic model from scikit-learn, such as a decision tree or logistic regression, and evaluate it using data the model has not seen during training. This also helps reveal issues with your data or evaluation process early, saving time and making later improvements more meaningful.

Use scikit-learn pipelines to prevent data leakage.

Use scikit-learn pipelines to keep data preparation and model training together, helping prevent data leakage. When preprocessing steps such as scaling or imputing missing values are fitted before splitting the data, information from the test set can influence the model and make its performance seem better than it really is. A pipeline fits these steps only on the training data and then applies the same transformations to the test data, keeping evaluation fair and reproducible.

Scale features when your model needs it.

Scale features when your model needs it: algorithms such as k-nearest neighbours, support vector machines and many gradient-based models can be affected by features measured on very different scales. For example, a model may give too much influence to income measured in thousands simply because it has larger numbers than age. In Python, use tools such as `StandardScaler` or `MinMaxScaler` from `scikit-learn`, and fit the scaler on your training data only before applying it to both training and test data. Tree-based models, such as decision trees and random forests, generally do not require feature scaling.

Choose metrics that match your task.

Choose evaluation metrics that reflect what matters for your task. Accuracy can be useful when classes are balanced, but it may hide poor performance on rare cases. For classification, consider precision, recall or the F1 score; for numerical predictions, measures such as mean absolute error may be more appropriate. The right metric depends on the consequences of different mistakes, so choose one that aligns with your real-world goals.

Tune hyperparameters using cross-validation.

Tune your model’s hyperparameters using cross-validation rather than relying on a single train–test split. Cross-validation divides the training data into several folds, training the model on some folds and evaluating it on the remaining one in turn. This gives a more reliable picture of how different settings are likely to perform on unseen data and helps you choose values that generalise well, rather than simply fitting one particular split. Keep a separate test set for a final, unbiased evaluation once tuning is complete.

Set random seeds for reproducible results.

Set random seeds to make your machine-learning results reproducible. Many Python libraries use randomness when splitting data, initialising models or shuffling examples, so repeated runs can produce different results. Setting a seed helps you recreate the same experiment, making it easier to compare models, debug code and share your findings. For example, use `random_state=42` in scikit-learn functions, and set seeds for other libraries you use, such as Python’s `random`, NumPy or PyTorch. A fixed seed improves consistency, though it does not guarantee identical results across every system or software version.

behaveannual.org

Driving Positive Change through Behavioral Science