This article is a simple example of how to use Scikit-Learn to create a simple classifier based on the Iris dataset.
Installation
In this example, we use Python version 3.12.0 together with virtualenv. Ubuntu 24.04 comes with Python 3.12 pre-installed.
To install Python 3.12 on MacOS, you can use Homebrew:
brew install python@3.12
On Windows, you can use the official Python installer from the Python website.
Later we also use Docker to run the Python code in a container. The easiest way to install Docker is to install
Docker Desktop. For Linux, you can alternatively install Docker Engine natively.
Create the Project with a Hello World Python script
First, create a new directory for the project and navigate into it. Then create a new file called main.py
with
the following content:
def main():
print("Hello, world!")
if __name__ == '__main__':
main()
This is a simple Python script that prints "Hello, world!" to the console. Try running it with the following command:
python main.py
If your Python binary requires you to specify the version, you can use python3.12
instead of python
.
Initiate a virtual environment and install Scikit-Learn
Make sure you have virtualenv installed:
virtualenv --version
Then create a new virtual environment for the project:
virtualenv -p python3.12 venv
Activate the virtual environment:
source venv/bin/activate
Install Scikit-Learn:
pip install scikit-learn
To have a list of all the installed packages with their versions, you can run:
pip freeze > requirements.txt
This will dump all the installed packages into a file called requirements.txt
. This way, the next person who works on
the project can install the exact same versions of the packages.
Create a simple classifier with Scikit-Learn
Now that we have Scikit-Learn installed, let's create a simple classifier based on the Iris dataset. Change the content
of main.py
to the following:
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
def main():
"""
This function is a hello-world function for scikit-learn.
It loads the Iris dataset, splits it into training and testing sets, and trains a random forest classifier.
:return: The model
"""
# Load the Iris dataset
iris = load_iris()
X = iris.data
y = iris.target
# Split the dataset into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
# Train a random forest classifier
model = RandomForestClassifier()
model.fit(X_train, y_train)
# Print the model's accuracy
print(f'Model accuracy: {model.score(X_test, y_test)}')
return model
if __name__ == '__main__':
main()
Some explanations about the code:
- We load the Iris dataset using
load_iris()
from Scikit-Learn. Iris is a simple dataset with 150 samples and 4 features. - We split the dataset into training and testing sets using
train_test_split()
. We use 80% of the data for training and 20% for testing. - We train a random forest classifier using
RandomForestClassifier()
. This is a simple classifier that works well on the Iris dataset. - We print the model's accuracy on the test set using
model.score(X_test, y_test)
. - Finally, we return the trained model.
Try running the script with:
python main.py
You should see the model's accuracy printed to the console. In my case, the output was:
Model accuracy: 0.9
Dockerize the project
To run the Python code in a Docker container, use the docker init
command to create a new Dockerfile:
docker init
The prompt will ask you a few questions. Here are the answers you should provide:
-
What application platform does your project use? Select
Python
. It should be automatically detected. -
What version of Python do you want to use? It is also automatically detected. In my case, it was
3.12.3
. Just press Enter. -
What port do you want your app to listen on? Press Enter to accept the default value
8080
. -
What is the command you use to run your app? Enter
python main.py
.
The following resources will be added to your project:
- A
Dockerfile
that describes how to build the Docker image. - A
.dockerignore
file that specifies which files and directories to exclude from the Docker build context. - A
compose.yaml
file that describes how to run the Docker container. - A
README.Docker.md
file with instructions on how to build and run the Docker container.
To run the Docker container, use the following command:
docker compose up --build
This will build the Docker image and start the container. You should see the output of the Python script in the console.
Attaching to server-1
server-1 | Model accuracy: 1.0
server-1 exited with code 0
The next time you want to start the container, you can use:
docker compose up
It won't rebuild the image, so it will start faster.
Conclusion
This article showed you how to create a simple classifier using Scikit-Learn and run it in a Docker container. You learned how to:
- Install Python and Scikit-Learn.
- Create a simple Python script.
- Train a classifier on the Iris dataset.
- Dockerize the project and run it in a container.
You can now extend this example by trying different classifiers, datasets, or even building a web service around the classifier.
Scikit-Learn is a powerful library for machine learning, and Docker is a great way to package and run your Python code.
By building the Docker image for the target platform, you can deploy your application to the cloud with ease, or share it with others.
Top comments (0)