DEV Community: Sujitha

Creating a Docker Image and Pushing to DockerHub for a Python ML App

Sujitha — Fri, 25 Apr 2025 18:51:53 +0000

In this post, I’ll walk through how I built a simple machine learning app using Python, packaged it into a Docker image, and then pushed that image to DockerHub. This setup makes it easy to run the app on any machine, without worrying about installing dependencies or setting up the environment.

The Machine Learning App

The app trains a logistic regression model on the Iris dataset to classify flowers based on sepal and petal measurements. It loads the data, prints basic info, generates and saves visualizations, splits the dataset, trains the model, evaluates accuracy, and saves the trained model using Joblib.

Make sure to place the Iris.csv file in the same directory as app.py so that the script can access it during execution.

Here's the Python file used:

from pandas import read_csv
from matplotlib import pyplot
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import joblib

# Step 1: Load dataset
filename = "Iris.csv"
data = read_csv(filename)

# Step 2: Display data shape and preview
print("Shape of the dataset:", data.shape)
print("First 20 rows:\n", data.head(20))

# Step 3: Plot and save histograms silently
data.hist()
pyplot.savefig("histograms.png")
pyplot.close()  # Close the plot so it doesn't show up in prompt

# Step 4: Plot and save density plots silently
data.plot(kind='density', subplots=True, layout=(3,3), sharex=False)
pyplot.savefig("density_plots.png")
pyplot.close()

# Step 5: Convert to NumPy array and extract features/labels
array = data.values
X = array[:, 1:5]  # Features: Sepal/Petal measurements
Y = array[:, 5]    # Target: Species

# Step 6: Split data into training (67%) and testing (33%)
test_size = 0.33
seed = 7
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)

# Step 7: Create and train logistic regression model
model = LogisticRegression(max_iter=200)
model.fit(X_train, Y_train)

# Step 8: Evaluate and display accuracy
result = model.score(X_test, Y_test)
print("Accuracy: {:.2f}%".format(result * 100))

# Step 9: Save the trained model to a file
joblib.dump(model, "logistic_model.pkl")

Writing the Dockerfile

Once the app was working locally, the next step was to containerize it using Docker. For this, I created a simple Dockerfile that starts from a lightweight Python base image, installs the required dependencies, copies the code into the image, and defines the command to run the script when the container starts.

Here's the Dockerfile used:

FROM python:3.9-slim

RUN pip install pandas scikit-learn matplotlib joblib

COPY . .

CMD ["python", "app.py"]

This setup ensures that anyone who runs this image will get the same environment and behavior, no matter where they are.

Building the Docker Image

Once the Dockerfile was ready, I opened PowerShell, navigated to the project directory, and ran the following command:

Docker pulled the base image, installed the libraries, copied the code, and built the final image. The build process completed successfully, creating a local image tagged as sujisuki/24mcr111-ml:latest.

Pushing the Docker Image to DockerHub

With the image built locally, the next step was to make it available online by pushing it to DockerHub.

First, I logged into DockerHub from the terminal:

After authentication, I pushed the image to my repository:

Docker uploaded the image layers to the remote repository, and the image became publicly available at
https://hub.docker.com/r/sujisuki/24mcr111-ml.

Now anyone can pull and run this image on their system using a single command.

Creating a Docker Image and Pushing to DockerHub for a Python ML App

Sujitha — Fri, 25 Apr 2025 18:51:53 +0000

The Machine Learning App

Make sure to place the Iris.csv file in the same directory as app.py so that the script can access it during execution.

Here's the Python file used:

from pandas import read_csv
from matplotlib import pyplot
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
import joblib

# Step 1: Load dataset
filename = "Iris.csv"
data = read_csv(filename)

# Step 2: Display data shape and preview
print("Shape of the dataset:", data.shape)
print("First 20 rows:\n", data.head(20))

# Step 3: Plot and save histograms silently
data.hist()
pyplot.savefig("histograms.png")
pyplot.close()  # Close the plot so it doesn't show up in prompt

# Step 4: Plot and save density plots silently
data.plot(kind='density', subplots=True, layout=(3,3), sharex=False)
pyplot.savefig("density_plots.png")
pyplot.close()

# Step 5: Convert to NumPy array and extract features/labels
array = data.values
X = array[:, 1:5]  # Features: Sepal/Petal measurements
Y = array[:, 5]    # Target: Species

# Step 6: Split data into training (67%) and testing (33%)
test_size = 0.33
seed = 7
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=seed)

# Step 7: Create and train logistic regression model
model = LogisticRegression(max_iter=200)
model.fit(X_train, Y_train)

# Step 8: Evaluate and display accuracy
result = model.score(X_test, Y_test)
print("Accuracy: {:.2f}%".format(result * 100))

# Step 9: Save the trained model to a file
joblib.dump(model, "logistic_model.pkl")

Writing the Dockerfile

Here's the Dockerfile used:

FROM python:3.9-slim

RUN pip install pandas scikit-learn matplotlib joblib

COPY . .

CMD ["python", "app.py"]

This setup ensures that anyone who runs this image will get the same environment and behavior, no matter where they are.

Building the Docker Image

Once the Dockerfile was ready, I opened PowerShell, navigated to the project directory, and ran the following command:

Pushing the Docker Image to DockerHub

With the image built locally, the next step was to make it available online by pushing it to DockerHub.

First, I logged into DockerHub from the terminal:

After authentication, I pushed the image to my repository:

Docker uploaded the image layers to the remote repository, and the image became publicly available at
https://hub.docker.com/r/sujisuki/24mcr111-ml.

Now anyone can pull and run this image on their system using a single command.

Advanced Git Commands

Sujitha — Fri, 25 Apr 2025 18:05:23 +0000

1. git diff: See What’s Changed

git diff shows you the difference between various states of your code. This can be between your working directory and the staging area, or between commits.

2. git log: Explore Your Project History

git log helps you see a list of all the commits that have been made in a repository.

3. git clone: Copy an Existing Repository

git clone lets you make a full copy of a Git repository from a remote source (like GitHub) to your local machine.

git clone https://github.com/username/repository.git

This creates a directory with the entire project history and working files.

4. git pull: Bring Changes from Remote to Local

git pull fetches the changes from the remote repository and merges them into your local branch.

git pull origin main

This fetches and merges the changes from the main branch on the remote.

5. git blame: Track Who Changed What

git blame shows who last modified each line of a file and when.

6. Git Merge Conflicts: When Things Don't Auto-Merge

Merge conflicts happen when Git can’t automatically resolve differences between branches. This usually happens when two people edit the same line in a file or delete a file that someone else modified.

7. git branch: Manage Code Versions

git branch lets you create, list, rename, and delete branches. Branching is key to isolating work, like developing new features or fixing bugs, without affecting the main codebase.

Common usage:

git branch — lists all branches.
git branch new-feature — creates a new branch.
git checkout new-feature — switches to that branch.
git checkout -b new-feature — creates and switches in one command.

8. .gitignore: Tell Git What to Skip

The .gitignore file tells Git which files or directories to ignore in a project.

Use cases:

Ignoring sensitive files like .env.
Skipping OS-generated files like .DS_Store or Thumbs.db.
Excluding build artifacts or dependencies like node_modules/.

node_modules/
.env
*.log

9. GitHub Wiki: Documentation Made Easy

Every GitHub repository can have its own Wiki — a place to host documentation, guides, project notes, or anything related to the repo.

Why it’s helpful:

Keeps project documentation organized and accessible.
Great for onboarding new contributors.
Easy to edit via the GitHub UI or clone and update like a regular Git repo.

To use it:

Navigate to the “Wiki” tab in your GitHub repository.
Click “Create the first page” to start documenting.
You can even clone the Wiki using git clone https://github.com/username/repository.wiki.git.

Final Thoughts

Git is much more than just add, commit, and push. Understanding commands like git diff, git blame, or how to resolve merge conflicts will give you more control and confidence in your version control workflow. Combine that with good practices like using .gitignore and documenting your projects with GitHub Wiki, and you'll be collaborating like a pro in no time.

Working With Git Commands

Sujitha — Wed, 23 Apr 2025 17:58:36 +0000

1. Initialize Your Git Repository

First things first, we need to turn your project folder into a Git repository. Open your terminal and run this command:
This creates a .git folder in your project, which allows Git to start tracking changes in your files.

2. Add Files to the Staging Area

Next, we need to tell Git which files we want to track. Use the following command to add all your changes:

3. Commit Your Changes

Once your files are staged, it’s time to commit them to your local repository. A commit is like a snapshot of your project at a certain point. You can do this with:

Be sure to write a message that clearly describes what changes you're committing.

4. Configure Git (Username and Email)

Git needs to know who you are so it can associate commits with your identity. Set your name and email with:

> git config --global user.name "Your Name"
> git config --global user.email "your.email@example.com"

5. Add a Remote Repository

If you want to push your local project to a remote server, you'll need to link your local Git repository to a remote one. To do this, use:

git remote add origin <repository-url>

Replace <repository-url> with the URL of your remote repository, like this:

6. Check the Status of Your Files

To see what's going on with your files—whether they’re staged, modified, or untracked—use:
7. Work with Branches

Git allows you to work on different parts of your project without affecting the main codebase. To see what branches you have, run:

8. Push Your Changes to a Remote Repository

Now that you've committed your changes, it's time to push them to a remote repository like GitHub. To do this, run:

This sends your local changes to the remote repository on the main branch. If you’re using another branch, just replace main with the branch name.

9. View Your Commit History

If you want to see a list of all the commits you’ve made so far, use:

This will show you all the commits in reverse chronological order, with details like the commit ID, author, and message.

10. File Successfully Pushed to Git Repository

Once you've run all the above steps, your files are now successfully pushed to your Git repository.

You can go to your repository's URL and see the code, commits, and branches reflected online.

And that’s it! These are the core Git commands you’ll use to manage your code, track changes, and collaborate with others.