DEV Community: Bhuvaneshwari G

Dockerizing a Python Machine Learning Model

Bhuvaneshwari G — Fri, 25 Apr 2025 18:09:18 +0000

In this blog, I’ll walk you through how to create a Python model using the Iris dataset, train it, and then Dockerize it for deployment. Dockerizing a model ensures portability and easy deployment, so let’s get started.

Step 1: Training the Model

First, we will load the Iris dataset and train a simple logistic regression model. We’ll use libraries like pandas, scikit-learn, and joblib to do this.

Here’s the Python code:

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

# Load the dataset
filename = "Iris.csv"
data = read_csv(filename)

# Prepare the features and target
array = data.values
X = array[:, 1:5]  # Features
Y = array[:, 5]    # Target

# Split the data into training and testing sets
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.33, random_state=7)

# Train the logistic regression model
model = LogisticRegression(max_iter=200)
model.fit(X_train, Y_train)

# Evaluate the model
accuracy = model.score(X_test, Y_test)
print(f"Model Accuracy: {accuracy * 100:.2f}%")

# Save the trained model
joblib.dump(model, "logistic_model.pkl")

This script:

Loads the Iris dataset.
Splits it into features (X) and target (Y).
Trains a logistic regression model.
Saves the model using joblib for later use.

Step 2: Dockerizing the Model

Now, we’ll create a Docker container to deploy the model. Docker helps us package our Python environment, ensuring consistency no matter where we run the model.

1. Creating the Dockerfile

A Dockerfile defines how to build our Docker image. Here’s the Dockerfile that sets up our Python environment and installs the required libraries:

# Use a Python base image
FROM python:3.8-slim

# Set the working directory
WORKDIR /app

# Copy the local files into the container
COPY . /app

# Install dependencies
RUN pip install --no-cache-dir -r requirements.txt

# Expose the port
EXPOSE 5000

# Command to run the model
CMD ["python", "predict.py"]

This Dockerfile:

Uses a lightweight Python image.
Sets up the working directory and copies files.
Installs dependencies using pip.
Exposes port 5000 for the Flask API (explained next).

2. Creating the requirements.txt

The requirements.txt file contains the libraries needed for the model and the Flask app:

pandas
scikit-learn
joblib
flask

This file tells Docker which libraries to install in the container.

Step 3: Flask API for Prediction

Now, we need a Flask API to serve our trained model and handle predictions. Create a predict.py file:

import joblib
import pandas as pd
from flask import Flask, request, jsonify

app = Flask(__name__)

# Load the model
model = joblib.load("logistic_model.pkl")

@app.route("/predict", methods=["POST"])
def predict():
    # Get the data from the request
    data = request.get_json(force=True)
    df = pd.DataFrame(data)

    # Make predictions
    predictions = model.predict(df)

    # Return the predictions
    return jsonify(predictions.tolist())

if __name__ == "__main__":
    app.run(debug=True, host="0.0.0.0")

In this API:

We load the saved model using joblib.
The predict endpoint accepts POST requests, takes the input data, and returns predictions from the model.

Step 4: Building and Running the Docker Image

Let’s build the Docker image and run the container.

Build the Docker image:

docker build -t iris-model .

Run the Docker container:

docker run -p 5000:5000 iris-model

Now, the model API is up and running on localhost:5000.

Step 5: Pushing the Docker Image to Docker Hub

To share your model, push the Docker image to Docker Hub. Here’s how:

Login to Docker Hub:

docker login

Tag the Docker image:

docker tag iris-model <your-dockerhub-username>/iris-model:latest

Push the image:

docker push <your-dockerhub-username>/iris-model:latest

This makes your model accessible to anyone with Docker, ready to be deployed anywhere!

Conclusion

You’ve just learned how to:

Train a machine learning model on the Iris dataset.
Dockerize the model and its environment.
Deploy the model using a Flask API.
Push the Docker image to Docker Hub for easy sharing.

This process ensures that your model is portable and ready for deployment. Docker makes it easy to scale and manage models in production.

Git Good: A Beginner’s Journey Into Advanced Git (With Real Examples)

Bhuvaneshwari G — Fri, 25 Apr 2025 15:42:25 +0000

10 Advanced Git Commands You Should Know

Hey folks! 👋

So after surviving git init, git add, and all the noob stuff on Day 1, it’s time to level up. Today, I explored some advanced Git commands, the kind that make you feel like a real dev.

Here’s a breakdown of 10 Git commands every serious coder should know.

1. `git diff`

This command shows the differences between your commits or files.

git diff

💬 "You edited something? Git will show you exactly what's different."

2. `git log`

This one gives you a detailed history of your commits — author, time, hash, message.

git log

💬 "Kinda like your browser history, but for code. No incognito mode here."

3. `git clone`

You can bring a GitHub repo to your local system with this:

git clone <repo-url>

🧠 Note: If someone made changes to the repo after you cloned, your local copy won’t have those changes unless you pull them.

4. `git fork`

When you fork a repo on GitHub, you’re creating a full copy of someone else's repo into your GitHub account.

Useful when:

You want to contribute
You want to customize it as your own

👨‍🍳 "Think of it like copying your friend’s biryani recipe to your own recipe book and adding extra spice 🌶️."

5. `git pull`

It fetches and merges changes from the remote to your local branch.

git pull origin main

💬 "If someone else made changes, this is how you get them."

6. `git push`

This uploads your local commits to GitHub.

git push origin main

💬 "Think of it as ‘post to Instagram’ but for code."

7. `git blame`

This shows who wrote each line of code.

git blame <file>

💬 "Want to know who broke the build? Blame 'em. Literally."

8. Merge Conflicts 🥲

When two people make conflicting changes in the same file — Git will cry. And so will you.

Fix it by:

Reading the conflict markers (<<<<<<<, =======, >>>>>>>)
Deciding what to keep
Committing the resolved file

💬 "It’s like two friends editing a group message at the same time… someone’s gonna get mad."

9. `git branch`

Used to create or list branches.

git branch feature-x

💬 "Work on new features without messing up your main code. Like parallel universes, but for bugs."

10. `.gitignore`

Used to exclude files/folders from being pushed to GitHub.

Just create a .gitignore file and list things like:

node_modules/
.env
*.log

💬 "Hide your secrets and junk before pushing your repo into the world."

Thanks for reading! Hope this post made advanced Git feel a little less scary and a lot more fun

11 Essential Git Commands Every Beginner Should Know (With Screenshots)

Bhuvaneshwari G — Wed, 23 Apr 2025 17:51:42 +0000

1. git init
Initializes a new Git repo in your current directory.

Explanation: This command turns the current folder into a Git-tracked project.

2. git add
Adds files to staging.
Example: git add .(adds all files)

Explanation: Staging is like prepping your files before committing.

3. git commit
Saves changes with a message.
Example: git commit -m "Initial commit"

Explanation: It's like hitting "Save" for your project history.

4. git status
Shows the current status of files.

Explanation: Tells you what’s been modified, staged, or untracked.
line.

5. git log
Shows commit history.

Explanation: Your project’s time machine.

6. git branch
Lists all branches.

Explanation: Also used to create branches: git branch feature-xyz

7. git branch -M
Renames your branch.
Example: git branch -M main

Explanation: Use it to switch from master to main (the new standard).

8. git config user.name
Sets your username.
Example: git config --global user.name "YourName"

Explanation: Git will tag commits with this name.

9. git config user.email
Sets your email.
Example: git config --global user.email "you@example.com"

Explanation: GitHub uses this to link commits to your account.

10. git remote add origin
Connects your repo to GitHub.
Example: git remote add origin https://github.com/yourusername/yourrepo.git

Explanation: This sets the destination where you push your code.

11. git push
Sends your commits to GitHub.
Example: git push -u origin main

Explanation: Think of it as uploading your progress online.

AHH! Finally!