Posts Tagged


Demand Clustering and Segmentation with Machine Learning in Logistics (Kmeans, scikit-learn, matplotlib)

Demand Clustering and Segmentation with Machine Learning in Logistics (Kmeans, scikit-learn, matplotlib)

In the field of logistics, understanding and predicting customer demand patterns is crucial for optimizing supply chain operations. By employing machine learning techniques, we can cluster and segment demand data to uncover valuable insights and make informed decisions. In this tutorial, we will explore how to perform demand clustering and segmentation using Python and popular machine learning libraries.


To follow along with this tutorial, you’ll need:

  • Python 3.x installed on your system
  • The following Python libraries: pandas, numpy, scikit-learn, matplotlib

You can install the required libraries using pip:

pip install pandas numpy scikit-learn matplotlib

Step 1: Data Preparation

The first step is to gather and prepare the demand data for analysis. This typically involves loading the data into a pandas DataFrame and performing any necessary preprocessing steps such as handling missing values or normalizing the data. For this tutorial, we’ll assume you have a CSV file containing demand data with the following columns: dateproduct_idquantity.

Let’s start by importing the necessary libraries and loading the data:

import pandas as pd

# Load the demand data from CSV
demand_data = pd.read_csv('demand_data.csv')

Next, we can examine the data and perform any necessary preprocessing steps. This might include handling missing values, converting data types, or normalizing the data. Preprocessing steps will vary depending on the specific dataset and requirements of your analysis.

Step 2: Feature Engineering

To apply machine learning algorithms, we need to extract relevant features from the demand data. In this tutorial, we’ll use the following features: product_idquantity, and date (as a temporal feature). We’ll transform the date column into separate features such as year, month, day, and day of the week. Additionally, we can include other domain-specific features if available, such as product category or customer segment.

Let’s create a function to perform feature engineering:

from datetime import datetime

def engineer_features(data):
    # Convert date column to datetime
    data['date'] = pd.to_datetime(data['date'])
    # Extract year, month, day, and day of the week
    data['year'] = data['date'].dt.year
    data['month'] = data['date'].dt.month
    data['day'] = data['date']
    data['day_of_week'] = data['date'].dt.dayofweek
    # Include other relevant features if available
    return data
# Apply feature engineering
demand_data = engineer_features(demand_data)

Step 3: Demand Clustering

Now that we have prepared our data and engineered the necessary features, we can proceed with demand clustering. Clustering is an unsupervised learning technique that groups similar instances together based on their features. In our case, we want to cluster demand patterns based on the extracted features.

For this tutorial, we’ll use the popular K-means clustering algorithm. Let’s import the required libraries and perform the clustering:

from sklearn.cluster import KMeans

# Select relevant features for clustering
features = ['quantity', 'year', 'month', 'day', 'day_of_week']
# Perform clustering
kmeans = KMeans(n_clusters=3)
clusters = kmeans.fit_predict(demand_data[features])

In the code above, we selected the features to be used for clustering (quantityyearmonthdayday_of_week) and specified the number of clusters to be 3. You can adjust these parameters according to your specific use case.

Step 4: Demand Segmentation

Once we have performed demand clustering, we can further segment the clusters to gain deeper insights into different customer demand patterns. Segmentation helps us understand distinct groups within each cluster, allowing us to tailor our logistics strategies accordingly.

In this tutorial, we’ll use the K-means clustering results to perform segmentation. We’ll calculate the centroid of each cluster and assign demand data points to the nearest centroid. This will help us identify which products or time periods belong to each segment within a cluster.

Let’s continue with the code:

# Add cluster labels to the demand data
demand_data['cluster'] = clusters

# Calculate the centroid of each cluster
cluster_centroids = pd.DataFrame(kmeans.cluster_centers_, columns=features)
# Segment the demand data based on cluster centroids
segment_labels = kmeans.predict(cluster_centroids)
demand_data['segment'] = demand_data['cluster'].apply(lambda x: segment_labels[x])

In the code above, we added the cluster labels to the demand data. Then, we calculated the centroid of each cluster using the cluster_centers_ attribute of the K-means model. Next, we predicted the segment labels for each cluster centroid using the predict method. Finally, we assigned the segment labels to the demand data based on their corresponding cluster.

Step 5: Visualizing Clusters and Segments

To better understand the clustering and segmentation results, it’s helpful to visualize them. We can plot the clusters and segments on different charts to observe patterns and identify differences between them.

Let’s create a scatter plot to visualize the clusters:

import matplotlib.pyplot as plt

# Plot clusters
plt.scatter(demand_data['quantity'], demand_data['year'], c=demand_data['cluster'])
plt.title('Demand Clusters')

Similarly, we can create a bar chart to visualize the segments:

segment_counts = demand_data['segment'].value_counts()

# Plot segments, segment_counts.values)
plt.title('Demand Segments')

By visualizing the clusters and segments, we can gain insights into the distinct demand patterns within our data. This information can be used to make data-driven decisions and optimize logistics operations accordingly.

In this tutorial, we explored how to perform demand clustering and segmentation using machine learning in logistics. We learned how to prepare the data, engineer relevant features, apply clustering algorithms, and segment the results. Additionally, we visualized the clusters and segments to gain insights into the demand patterns.

By employing these techniques, logistics professionals can effectively analyze customer demand, uncover hidden patterns, and optimize their supply chain operations for improved efficiency and customer satisfaction.

Remember, demand clustering and segmentation is just one aspect of utilizing machine learning in logistics. There are many other techniques and models that can be applied to tackle different challenges in the field. So feel free to explore further and expand your knowledge!

Happy coding!

Brain Tumor Segmentation with U-Net in Python: A Deep Learning Approach

Brain Tumor Segmentation with U-Net in Python: A Deep Learning Approach

Brain tumor segmentation is an important task in medical image analysis that involves identifying the location and boundaries of tumors in brain images. In this tutorial, we will explore how to use the U-Net architecture to build a brain tumor segmentation model in Python using the TensorFlow and Keras libraries.


We will use the BraTS 2019 dataset, which contains brain MRI scans with ground truth segmentation labels. The dataset can be downloaded from here.

Environment Setup

Before we begin, we need to set up our environment. We will be using Python 3.7 and the following libraries:

  • TensorFlow
  • Keras
  • NumPy
  • Matplotlib
  • SimpleITK

You can install these libraries using the following command in your command prompt or terminal:

pip install tensorflow keras numpy matplotlib SimpleITK

Loading the Dataset

We will start by loading the BraTS 2019 dataset using the SimpleITK library:

import SimpleITK as sitk

# Load the MRI scan and ground truth segmentation labels
mri = sitk.ReadImage('BraTS2019/MRI.nii.gz')
seg = sitk.ReadImage('BraTS2019/Segmentation.nii.gz')
# Convert the images to arrays
mri_array = sitk.GetArrayFromImage(mri)
seg_array = sitk.GetArrayFromImage(seg)

Preprocessing the Data

We need to preprocess the data before feeding it to the U-Net model. We will normalize the pixel values and resize the images to a fixed size.

import numpy as np
from keras.preprocessing.image import ImageDataGenerator

# Normalize the pixel values
mri_array = (mri_array - np.min(mri_array)) / (np.max(mri_array) - np.min(mri_array))
# Resize the images to a fixed size
new_shape = (256, 256, 128)
mri_resized = np.zeros(new_shape)
seg_resized = np.zeros(new_shape)
for i in range(mri_array.shape[0]):
    mri_resized[i] = resize(mri_array[i], new_shape, preserve_range=True)
    seg_resized[i] = resize(seg_array[i], new_shape, preserve_range=True)
# Split the data into training and validation sets
train_mri, val_mri, train_seg, val_seg = train_test_split(mri_resized, seg_resized, test_size=0.2, random_state=42)

Building the Model

We will use the U-Net architecture for brain tumor segmentation, which is a convolutional neural network that consists of an encoder and a decoder. The encoder compresses the input MRI images into a lower-dimensional representation, while the decoder expands this representation to generate the final segmentation mask. We will implement the U-Net architecture using TensorFlow and Keras.

# Encoder
inputs = keras.layers.Input(shape=input_shape)
conv1 = keras.layers.Conv3D(8, 3, activation='relu', padding='same')(inputs)
conv1 = keras.layers.Conv3D(8, 3, activation='relu', padding='same')(conv1)
pool1 = keras.layers.MaxPooling3D(pool_size=(2, 2, 2))(conv1)
conv2 = keras.layers.Conv3D(16, 3, activation='relu', padding='same')(pool1)
conv2 = keras.layers.Conv3D(16, 3, activation='relu', padding='same')(conv2)
pool2 = keras.layers.MaxPooling3D(pool_size=(2, 2, 2))(conv2)
conv3 = keras.layers.Conv3D(32, 3, activation='relu', padding='same')(pool2)
conv3 = keras.layers.Conv3D(32, 3, activation='relu', padding='same')(conv3)
pool3 = keras.layers.MaxPooling3D(pool_size=(2, 2, 2))(conv3)
conv4 = keras.layers.Conv3D(64, 3, activation='relu', padding='same')(pool3)
conv4 = keras.layers.Conv3D(64, 3, activation='relu', padding='same')(conv4)
pool4 = keras.layers.MaxPooling3D(pool_size=(2, 2, 2))(conv4)
conv5 = keras.layers.Conv3D(128, 3, activation='relu', padding='same')(pool4)
conv5 = keras.layers.Conv3D(128, 3, activation='relu', padding='same')(conv5)
# Decoder
up6 = keras.layers.UpSampling3D(size=(2, 2, 2))(conv5)
up6 = keras.layers.concatenate([up6, conv4], axis=4)
conv6 = keras.layers.Conv3D(64, 3, activation='relu', padding='same')(up6)
conv6 = keras.layers.Conv3D(64, 3, activation='relu', padding='same')(conv6)
up7 = keras.layers.UpSampling3D(size=(2, 2, 2))(conv6)
up7 = keras.layers.concatenate([up7, conv3], axis=4)
conv7 = keras.layers.Conv3D(32, 3, activation='relu', padding='same')(up7)
conv7 = keras.layers.Conv3D(32, 3, activation='relu', padding='same')(conv7)
up8 = keras.layers.UpSampling3D(size=(2, 2, 2))(conv7)
up8 = keras.layers.concatenate([up8, conv2], axis=4)
conv8 = keras.layers.Conv3D(16, 3, activation='relu', padding='same')(up8)
conv8 = keras.layers.Conv3D(16, 3, activation='relu', padding='same')(conv8)
up9 = keras.layers.UpSampling3D(size=(2, 2, 2))(conv8)
up9 = keras.layers.concatenate([up9, conv1], axis=4)
conv9 = keras.layers.Conv3D(8, 3, activation='relu', padding='same')(up9)
conv9 = keras.layers.Conv3D(8, 3, activation='relu', padding='same')(conv9)

outputs = keras.layers.Conv3D(1, 1, activation='sigmoid')(conv9)

# Create the model
model = keras.models.Model(inputs=[inputs], outputs=[outputs])

Training the Model

We will compile the model and train it on the training set:

# Compile the model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the model
history =, train_seg, batch_size=1, epochs=50, validation_data=(val_mri, val_seg))

Evaluating the Model

Finally, we will evaluate the model on the test set:

test_mri = sitk.ReadImage('BraTS2019/Test/MRI.nii.gz')
test_seg = sitk.ReadImage('BraTS2019/Test/Segmentation.nii.gz')
test_mri_array = sitk.GetArrayFromImage(test_mri)
test_seg_array = sitk.GetArrayFromImage(test_seg)

# Normalize and resize the test images
test_mri_array = (test_mri_array - np.min(test_mri_array)) / (np.max(test_mri_array) - np.min(test_mri_array))
test_mri_resized = np.zeros(new_shape)
for i in range(test_mri_array.shape[0]):
    test_mri_resized[i] = resize(test_mri_array[i], new_shape, preserve_range=True)

# Predict the tumor segmentation masks for the test images
test_mri_resized = np.expand_dims(test_mri_resized, axis=4)
test_pred = model.predict(test_mri_resized, verbose=1)

# Evaluate the model using Dice coefficient
test_dice = dice(test_pred, test_seg_array)
print('Test Dice coefficient:', test_dice)

In this tutorial, we have demonstrated how to use deep learning to perform brain tumor segmentation on MRI images. We have used the U-Net architecture, which is a popular convolutional neural network for medical image segmentation. We have also demonstrated how to use TensorFlow and Keras to implement the U-Net model.

Brain tumor segmentation is a challenging problem, and deep learning has shown great promise in this area. With the availability of large annotated datasets and powerful deep learning frameworks, it is now possible to build accurate and robust segmentation models for clinical use.

We hope that this tutorial has been useful in understanding how to perform brain tumor segmentation with deep learning. If you have any questions or suggestions, please feel free to leave a comment below.