Machine Learning | Alan Hung

Improving fabric sales through cluster analysis

Tue, 05 Feb 2019 00:00:00 +0000

Table of Contents

Abstract

We performed cluster analysis and regression on our fabric sales data. Due to the subjective nature of fabric, the features we extracted were not enough to make precise predictions. However, leveraging the results from cluster analysis has improved our sales in two ways:

First, by providing labels for each cluster, we have given buyers a more organized way to make purchases, resulting in a 50% reduction in processing time for each purchase.

Second, by identifying the clusters that may lead to high inventory levels, we can allocate our budget more effectively, resulting in up to a 4x improvement in sales.

1. Introduction

Understanding customers’ needs is one of the key strategies to increase sales. For fabric retailers, this can be particularly challenging due to the subjective nature of fabric as a visual artwork. Each customer may have different preferences, which can result in high inventory levels if purchased fabric does not meet their needs. Additionally, fabric selection has traditionally been carried out by experienced buyers, which can be prone to human error and exacerbate the issue.

To address these issues, we analyze the features extracted from our algorithms$^1$ $^2$ to gain insights into the fabric. This will help us better understand customer preferences and, consequently, improve sales.

2. Objectives

The objective of this project is to:

Categorize the fabric by features.
Identify the category with the most sales and the category with the highest inventory level.
Predict sales.
Develop a strategy to improve sales.

3. Dataset

Data was collected from the previous quarter’s sales results, including a total of 3000 fabrics. Table 1 lists detailed descriptions of the extracted features and target.

Feature	Unit	Type	Range	Description
HUE	degree	Numerical	[0, 359]	Hue of the dominant color.
PERCENT	-	Numerical	[0, 100]	Percentage of dominant color.
RANGE	degree	Numerical	[0, 359]	Range of colors.
THEME	-	Categorical	Monochrome, analogous, complementary, triadic, none	Color themes.
SIZE	$cm^2$	Numerical	[0, 1247.35]	Pattern size.
CONTRAST	-	Numerical	[0, 127.5]	Standard deviation in grayscale.
SALES	-	Numerical	[0, 100]	Percentage of sales.

Fig. 1 shows an example of a fabric property and its corresponding features. As the purchased quantity of each fabric varies, we use the percentage of sales for each fabric, which is calculated by dividing the total sales at the end of the month by the total purchases at the beginning of the month.

4. Exploratory data analysis

4.1. Distribution

We can perform a descriptive analysis by examining the distribution of each feature and its correlation with sales, as shown in the Fig. 2.

The percentage of blue and red is high in the main color (HUE). However, HUE is uncorrelated to SALES in Fig. 3, indicating that our customers have no significant preference for the main color of the fabric. Therefore, we will drop this feature in future analyses.

The RANGE and SIZE of the fabric are relatively small. This is reasonable, as it is difficult to design fabric with a wide color range, large pattern size. Regarding THEME, it is evident that the percentage decreases as the theme becomes more intricate. This makes sense since, similar to RANGE, designing becomes more challenging when there are more limitations on color usage to match the theme.

In terms of SALES performance, the mean is 40% and the distribution is mainly below this mark.

4.2. Correlation

Fig. 3 shows the correlation between SALES and features. Despite the low correlation, all below 0.5, we can still gain some insight into customer preferences.

All features, except for PERCENT, monochrome and non-specific color themes, are positively correlated with sales. This result is quite intuitive. Fig. 4 provides an example: Fabric A has a wider range of colors and a larger pattern size, as well as higher contrast. Additionally, it uses a triadic theme to balance red, blue, and green, resulting in higher visual appeal than Fabric B. Therefore, it is reasonable to assume that Fabric A has higher sales than Fabric B.

5. Models

Before conducting quantitative analysis, it’s important to split the data into training and test datasets. This is necessary for verification in the final step of the analysis. Additionally, data standardization is required to ensure that all features have a comparable range.

5.1. Dimensionality reduction

As there are both numerical and categorical features, the covariance matrix should be treated differently. For numerical features, we can follow the original definition. However, for categorical features, the covariance matrix is constructed by preserving the $\chi^2$ distance between features. Next, we can perform singular value decomposition on the covariance matrix to find the principal components. In summary, PCA (principal component analysis) and CA (correspondence analysis) are utilized to decrease feature dimensionality.

The results are shown in the Fig. 5 (a). We can use three principal components and still preserve 70% of the total variance. The loading of components are also shown in Fig. 5 (b).

5.2. Cluster analysis

5.2.1. K-means

After identifying the turning point in the elbow plot, as shown in Fig. 6 (a), we have decided to use 3 clusters for further analysis. For each cluster, we calculate the average of its features as shown in the Fig. 6 (b).

The first cluster, named “Colorful”, has higher values in RANGE, CONTRAST, and multiple color themes. The second cluster, named “Large pattern”, has the highest value in SIZE. In contrast to the first two clusters, the third cluster has only a large positive value in main color percentage (PERCENT) and monochrome color theme, so it is named “Plain” and should be considered less visually appealing than the first two clusters. Fig. 6 (c) provides examples of fabric for each cluster.

5.2.2. Sales and Stock

Fig. 7 (a) displays the histogram and cumulative curve for the percentage of sales. It is clear that the distribution of “Plain” fabric is highly concentrated near zero. The accompanying Fig. 7 (b) illustrates the portion of sales and stock. Although “Plain” fabric constitutes 60% of total stock, it only contributes to 31.9% of sales. In other words, the high inventory level is caused by the excess of “Plain” fabric. Therefore, we can improve our inventory control by reducing the total portion of “Plain” fabric in every purchase. Test data supports this conclusion (not shown).

While “Colorful” fabric has better sales, it also has a higher stock level. Additionally, the histogram and cumulative curve are similar for both “Colorful” and “Large pattern” fabrics. Therefore, based on the current information we have, we cannot determine which fabric performs better.

5.3 Regression

Another goal is to make predictions on sales. To do this, we can first examine the correlation between sales and components from dimension reduction. There is only one component that reaches -0.5, as shown in Fig. 8 (a), which can be used as a regressor. Secondly, we need to decide on the type of regression to use. As the response variable falls within the continuous range of [0, 1], it is recommended to use beta regression instead of linear or logistic regression ( Citation: Ferrari & Cribari-Neto, 2004 Ferrari, S. & Cribari-Neto, F. (2004). Beta regression for modelling rates and proportions. Journal of applied statistics, 31(7). 799–815. ) .

The results are shown in Fig. 8 (b). It is apparent that the accuracy, with only a 0.246 R-squared value, is low due to the low correlation between the component and SALES. In other words, the current features are still insufficient to make precise predictions.

6. Strategy to Improve Sales

While precise predictions may not be possible, we can still improve fabric sales by leveraging the results of cluster analysis. These improvements can be observed in two ways:

Firstly, by implementing tags such as “Colorful,” “Large Pattern,” and “Plain” in our in-house library and dashboard, as shown in Fig. 9, buyers can have a clearer summary of each category. This enables them to make decisions more confidently and efficiently.

Previously, we only made purchases in Q1 and Q3, while fabric sales were limited to Q2 and Q4, as indicated by the 2017 results in Fig. 10. However, after the implementation, we were able to make purchases and sales in all four quarters. In other words, the processing time for each purchase has been reduced from six months to three months.

Secondly, we can allocate our budget more effectively by being more cautious with our purchases of “Plain” fabric and investing in other fabrics instead. By comparing fabric sales in 2017/Q4 and 2018/Q1, we have observed an improvement of 2.73.

7. Conclusion

By using K-means, we divided the fabric from the previous quarter’s sales into three categories. We discovered that high inventory levels were due to fabrics with a monochrome color theme, high percentage of the main color, low contrast, and small pattern size. We collectively refer to this type of fabric as “Plain” fabric. While we have not been able to predict sales, categorizing fabric into these categories has proven to be one of the main factors in improving our sales.

Reference

Ferrari & Cribari-Neto (2004): Ferrari, S. & Cribari-Neto, F. (2004). Beta regression for modelling rates and proportions. Journal of applied statistics, 31(7). 799–815.

Design and Implementation of an in-House Fabric Library

Sun, 10 Dec 2017 00:00:00 +0000

Table of Contents

Abstract

This document highlights the need for a fabric library to improve efficiency in fabric-related businesses. To specify the library’s requirements, we consider three aspects: System, User, and Administrator. Based on these requirements, we define a workflow for the fabric library that includes feature extraction, machine learning, and web services. The library is implemented using the Django framework and deployed on the Google Cloud Platform. Finally, we evaluate the impact of this library, resulting in up to a 4x improvement in fabric sales and a 50% reduction in the purchase process time.

1. Introduction

As a fabric-related business, much of our daily work involves sifting through piles of fabric and communicating with team members using fabric images. This process is time-consuming, exhausting, and inefficient. For example, a designer may spend an hour in the warehouse just to find a particular color and pattern of fabric. Additionally, images may be attached to emails, social media, or even printed out during discussions among team members, making it difficult to systematically compare or review results. To address these issues, we need to create an application that can assist team members in finishing their work more efficiently.

2. Objectives

To be more specific, there are two parts in our original workflow that can be improved, as shown in Fig. 1:

Reducing the time spent on searching for fabric.
- Before: Workers need to search through all the fabric in the warehouse to find the desired one.
- After: Workers can input desired features of the fabric into the application, which will retrieve all fabrics that match the input criteria.
Streamlining the time spent on reviewing fabrics and making purchases more efficiently.
- Before: Workers and stakeholders are reviewing fabric using different tools, which can make it difficult for stakeholders to get a clear picture of all fabrics and can delay the decision-making process for purchases.
- After: Workers and stakeholders can have discussions based on the same information provided by the application. Additionally, the application’s data visualization and machine learning-based predictions can provide valuable insights into the fabric.

3. Requirement

To achieve our goals, we can break down the requirements of our application into three aspects: “System”, “User”, and “Administrator”.

System:
- Store and display information about fabrics
- Extract features from fabrics
- Use machine learning (ML) models to make sales predictions
- Provide a dashboard summarizing each order
User:
- Search and filter fabrics
- Retrieve similar fabrics
- Add fabrics to orders
Administrator:
- Evaluate results from ML models
- Batch update the database

Regarding the requirements of the System, it should be able to store fabric information and display it to users. Additionally, it needs to extract features from the fabric so that users can search, filter, and retrieve similar fabric based on those features. Furthermore, the extracted features can be used in ML models to predict sales and can also be used in a dashboard to help stakeholders or buyers have a clearer view of the order list, enabling them to make decisions more efficiently.

For User, in addition to searching for fabric, they should be able to add fabrics to their wishlist, cart, or order. As for the Administrator, metrics should be defined so that they can evaluate the ML models that make predictions on sales. Since the supplier will frequently provide new fabrics, batch updates are preferable instead of updating them one by one.

4. Workflow

The workflow can be designed logically by considering all the requirements, as shown in Fig. 2.

Bucket: To allow fabric suppliers to upload images of fabrics and serve them to our web service, we need to create a cloud storage bucket.

Image Preprocessing: Images added to the bucket need to be resized to reduce runtime in feature extraction. Additionally, converting the color space from RGB to HSV is necessary for color theme extraction.

Features Extraction: During this stage, features such as the main color, pattern size, and color theme are extracted. Furthermore, we need to obtain sales data for each fabric to use as a target for machine learning.

Machine Learning: At this stage, we perform both supervised and unsupervised learning, as described in the Implementation Details section.

Model Evaluation: When using machine learning techniques, corresponding metrics are used to evaluate the models. For example, in linear regression, the $R^2$ metric is used for accuracy assessment.

Database: The extracted features and predictions from ML models will be updated in the database.

Web Service: We use Python for the backend and HTML, JavaScript, and CSS for the frontend to create a web service.

Web Server: Since we are using Python on the backend, we can transfer HTTP requests and responses using WSGI. This can be accomplished by using Apache and its modules.

Client: Our system only requires three functions for users: searching and filtering fabrics, retrieving similar fabrics, and adding fabrics to an order.

5. Result

Our web service consists of a main page, fabric detail pages, and an order summary page, all shown in the Fig. 3.

5.1. Main Page

On the left side of the webpage, there are multiple sliders that can be used to filter the range of each feature, including color, pattern size, contrast, and so on. The web page will then display fabrics that match the selected criteria. As for the color theme, since it is a categorical feature, it is designed as a checkbox. Additionally, users can input a fabric ID to retrieve specific fabrics.

5.2. Fabric Detail Pages

The polar plot displays the color theme and range. Additionally, histograms of each channel are shown, and the percentage of each color is displayed. Quantitative features such as pattern size and contrast are also included. Finally, the top 12 options for similar fabrics are listed at the bottom of the page.

5.3 Order Summary Page

This page serves as an interactive dashboard that not only summarizes the order for the user, but also allows the user to adjust the quantity of fabric to see its impact on the order.

At the top of the page, there are two pie charts displaying the labels predicted by K-means. These charts remind the user about the proportion of each label. A higher proportion of a specific label, especially “Plain”, may be risky for sales, as discussed in the previous project.

The price and quantity of the order are displayed in the center of the page. Users can adjust the quantity using buttons provided.

Finally, the features of the fabrics are summarized using a violin plot and a pie chart located at the bottom of the page, which provide insight into the distribution of the features.

5.4 Impact

5.4.1. Efficiency

During the feature extraction stage, we implement algorithms that achieve 12x and 63x improvements in speed compared to human processing for extracting pattern size and color themes, respectively$^1$ $^2$.

When it comes to finding similar fabrics, defining the metric can be difficult due to the subjective nature of fabric images. However, the implemented algorithm has been proven to retrieve fabrics that are similar to those perceived by humans$^3$.

5.4.2. Sales

Thanks to our in-house library and the hard work of our team members, sales have increased significantly since 2018, as shown in Fig. 4. We have observed up to a 2.73 improvement compared to 2017. Additionally, we have reduced the process time for each purchase by 50%, as discussed in a previous project.

6. Conclusion

We take a systematic approach to building an in-house library for fabric. This approach includes analyzing requirements, selecting a framework, implementation, and deployment. The library has proven to be useful in significantly increasing sales and reducing the time required for the purchase and design process.

7. Appendix: Implementation Details

7.1. Framework

As Python is our main programming language, we have opted to use the Django framework to construct our web service. This framework offers all the essential components and features, including frontend development with JavaScript, HTML, and CSS, and backend interaction through an object-relational mapper (ORM).

7.2. Image Preprocessing and Feature Extraction

We use OpenCV with Python for image manipulation tasks, such as importing, exporting, resizing, and color space conversion. We also implement our own algorithm to extract features, including color themes and pattern sizes. Similar fabrics are also considered as a feature and are extracted based on perceptual similarity.

7.3. Machine learning and Model Evaluation

We perform dimensionality reduction, K-means clustering, and beta regression on the extracted features. The procedure and results are discussed in the previous project.

7.4. Database

7.4.1. Schema

Fig. 5 provides a simplified schema as an example. We have created a “Fabric” table to store the features of fabrics. For each item in an order, we create an “OrderItem” table and use “order_id” and “fabric_id” as foreign keys. Lastly, for each order, an “Order” table is created, with “user_id” used as the foreign key.

7.4.2. Batch update

To perform batch updates in a database using Django, we create a custom django-admin command. The following is an example of importing CSV data and writing it into the “Fabric” table in a database.

class Command(BaseCommand):
    help = "load fabric data"

    def handle(self, *args, **options):
        # Custom function for loading data in CSV format
        data = load_data(file="./example.csv")
				
        for i in range(1, len(data)):
            # Write data to each column
            row_data = {}
            row_data["fabric_name"] = data[i][0]
            row_data["main_color"] = data[i][1]
            ...
            # Save data to Fabric table
            item = Fabric(**row_data)
            item.save()

7.5. Web Service

We use Django’s class-based views to build our web pages. Setting up the connection with the database and template only requires few lines of code. Additionally, built-in pagination can be used to achieve multi-page content.

class ShopView(ListView):
    model = Fabric  # Table name in database
    paginate_by = 6  # 6 items for each page
    template_name = "shop/shop.html"

Meeting user requirements for filtering or searching fabric involves setting up a frontend user interface to receive user requests and a backend to query the database.

To achieve this on the frontend, a classic range slider and a checkbox can be used. On the backend, we need to use the “setup” method to receive these requests from the frontend, parse them, and make a query to the database using “get_queryset”. The following code provides an example of how to filter content in shop.html based on a user’s request for a specific hue range.

class ShopView(ListView):
    model = Fabric  # Table name in database
    paginate_by = 6  # 6 items for each page
    template_name = "shop/shop.html"
    filters = {}

    def setup(self, request, *args, **kwargs):
        """Initialize attributes shared by all view methods."""
        super().setup(request, *args, **kwargs)
        self.parse_request()

    def get_queryset(self):
        """Make queries to the database."""
        new_queryset = Fabric.objects.filter(**self.filters)
        return new_queryset
    
    def parse_request(self):
        """Receive request and update to filter for queryset"""
        low = self.request.GET.get("hue_low")
        high = self.request.GET.get("hue_high")
        self.filters["hue__range"] = [low, high]

Another requirement is to keep track of the order list across different pages. This can be achieved by using cookie in frontend. The following example demonstrates how to update a cart’s content in a cookie using JavaScript.

function updateCart(cart){
    document.cookie = "cart=" + JSON.stringify(cart)
}

function updateQuantity(fabricName, quantity, cart) {
    if (fabricName in cart) {
        cart[fabricName] = parseInt(cart[fabricName]) + parseInt(quantity)
    } else {
        cart[fabricName] = parseInt(quantity)
    }
    updateCart(cart)
}

7.6. Web Server

As our web service is built with Python, we can use WSGI to forward requests from the web server. Apache with mod_wsgi provides a simple way to set up a directory for Python scripts, and virtual environments in the configuration file. The following code provides an example:

<Macro DjangoWSGI $document $script>
    WSGIDaemonProcess demo python-home="$script/venv" python-path="$script"
    WSGIProcessGroup demo
    WSGIScriptAlias / "$script/site_settings/wsgi.py"
    <Directory "$script/site_settings">
        <Files wsgi.py>
            Require all granted
        </Files>
    </Directory>
</Macro>

7.7. Client (User Interface)

We have created three pages for our user interface based on our requirements: the main page, fabric detail pages, and order summary page, as shown in Fig. 6.

7.7.1. Main Page

We use range sliders to allow users to specify the range of each feature. A search box is used to retrieve fabric based on the fabric’s ID.

To create range sliders, begin by adding three progress bars that will serve as its appearance.

<div class="wrap-filter-bar">
    <div id="hue-filter-bar">
        <div class="hue-progress"></div>
        <div class="hue-progress-mask-left"></div>
        <div class="hue-progress-mask-right"></div>
    </div>
</div>

Next, add two inputs to specify the upper and lower bounds of the feature.

<div class="hue-input">
    <div class="field">
        <label for="hue_min">
            <input type="range" id="hue_min"...>
        </label>
        <label for="hue_max">
            <input type="range" id="hue_max"...>
        </label>
   </div>
</div>

Add an event listener to each input to update the progress bars based on the user’s input.

function slider(name, gap) {
    // Retrieve html elements
    let rangeInput = document.querySelectorAll(`.${name}-input input`);
    let progress = document.querySelector(`.leftbar #${name}-filter-bar .${name}-progress`);
    let progressMaskLeft = document.querySelector(`.leftbar #${name}-filter-bar .${name}-progress-mask-left`);
    let progressMaskRight = document.querySelector(`.leftbar #${name}-filter-bar .${name}-progress-mask-right`);

    // Add event listener
    rangeInput.forEach(input => {
        input.addEventListener("input", function (event) {
            // Retrieve value from input
            let minVal = parseInt(rangeInput[0].value)
            let maxVal = parseInt(rangeInput[1].value)

            // Update progress bar
            if (maxVal - minVal < gap) {
                if (event.target.className === `${name}-min`) {
                    rangeInput[0].value = maxVal - gap;
                } else {
                    rangeInput[1].value = minVal + gap;
                }
            } else {
                updateProgressAndDisplay(...);
            }
        });
    });
}

Finally, create a button to submit the input values to the backend.

<button type="submit">Filter</button>

A search box can be created simply by using HTML.

<div class="search-product">
    <form class="search-box" method="GET" action="">
        <label for="search-product">
            <input type="text"
                   name="search-product"
                   id="search-product"
                   placeholder="Search Products...">
        </label>
        <button type="submit"></button>
    </form>
</div>

7.7.2. Fabric Detail Pages and Order Summary

The primary goal is to visualize the features for each fabric and summarize the order with plots. To achieve this, we rely on Plotly, JavaScript, and CSS, as they provide interactive and responsive plots for users. For example, a scatter plot can be created by providing the id of the HTML element and the x and y data, respectively.

function scatterPlot(plotID, x, y) {
    let data = [
        {
            x: x,
            y: y,
            type: "scatter",
            mode: "line",
        }
    ];
    Plotly.newPlot(plotID, data)
}

7.8. Cloud provider

We chose Google Cloud Platform (GCP) as our cloud provider because it has the lowest latency of 18 ms in Taiwan compared to AWS and Azure. Although GCP provides many convenient options for deploying a web service, such as App Engine or Cloud Run, we have chosen to use Compute Engine. The reason for this is that it allows for more precise control and direct management of virtual machines (VMs). For instance, we can select CPU and RAM according to our budget, and choose a region with the lowest latency.

Machine Learning | Alan Hung

Improving fabric sales through cluster analysis

Abstract

1. Introduction

2. Objectives

3. Dataset

Description of fabric’s features and target.

(a)show hide

(c)show hide

(b)show hide

(d)show hide

4. Exploratory data analysis

4.1. Distribution

Distribution of features.

HUEshow hide

PERCENTshow hide

RANGEshow hide

SIZEshow hide

CONTRASTshow hide

SALESshow hide

THEMEshow hide

4.2. Correlation

Correlation coefficient between sales and features.

To illustrate the correlation between sales and features, consider the example of two fabrics, A and B. Fabric A has a wider color range, larger pattern size, and higher contrast, resulting in higher visual appeal than B. Therefore, A is likely to have higher sales than B.

show hide

show hide

5. Models

5.1. Dimensionality reduction

(a) Variance explained after dimensionality reduction. (b) Loading of the first five principal components.

(a)show hide

(b)show hide

5.2. Cluster analysis

5.2.1. K-means

(a) Elbow plot of K-means analysis. (b) Naming each cluster based on the average value of its features. (c) Visualize the clusters using the first three principal components and provide an example fabric for each cluster.

(a)show hide

(b)show hide

(c)show hide

Colorfulshow hide

Large patternshow hide

Plainshow hide

5.2.2. Sales and Stock

(a) The histogram and cumulative curve, as well as (b) the sale and stock of each cluster, indicate that the Plain fabric is the root cause of high stock level.

(a)show hide

(a)show hide

5.3 Regression

(a) Correlation between sales and principal components. (b) Result from beta regression with a 0.246 R-squared value.

(a)show hide

(b)show hide

6. Strategy to Improve Sales

Example of an in-house library and dashboard that is integrated with tags from cluster analysis.

Fabric sales per quarter have been tracked since 2017. Since 2018, the purchase process has incorporated the results of cluster analysis, which has led to higher sales. Different colors indicate the before and after implementation.

7. Conclusion

Reference

Design and Implementation of an in-House Fabric Library

Abstract

1. Introduction

2. Objectives

The figure illustrates two scenarios: the original workflow before using the application, and the workflow after use of the application.

3. Requirement

4. Workflow

Workflow of our application

5. Result

Pages in our application.

Main Pageshow hide

Fabric Detail Pagesshow hide

Order Summary Pageshow hide

5.1. Main Page

5.2. Fabric Detail Pages

5.3 Order Summary Page

5.4 Impact

5.4.1. Efficiency

5.4.2. Sales

Fabric sales per quarter have been tracked since 2017. Since 2018, the purchase process has incorporated the in-house library, which has led to higher sales. Different colors indicate the before and after implementation.

6. Conclusion

7. Appendix: Implementation Details

7.1. Framework

7.2. Image Preprocessing and Feature Extraction

7.3. Machine learning and Model Evaluation

7.4. Database

7.4.1. Schema