In this paper we explored machine learning approaches using descriptions and titles to classify footwear by brand. The provided data were taken from many different online stores. In particular, we have created a pipeline that automatically classifies product brands based on the provided data. The dataset is provided in JSON format and contains more than 40,000 rows. The categorization component was implemented using K-Nearest Neighbour (K-NN) and Support Vector Machine (SVM) algorithms. The results of the pipeline construction were evaluated basing on the classification report, especially the Precision weighted average value was considered during the calculation, which reached 79.0% for SVM and 72.0% for K-NN.
Today, there is an enormous number of e-shops that allow consumers to buy goods online. As a
result, the number of products sold through e-shops grew rapidly. A recent study estimated that total
ecommerce retail sales were $791.70 billion in 2020, up 32.4% from the previous year's $598.02 billion.
This is the highest annual growth of digital technologies for any year for which data are available this
information reported by the Ministry of Trade in 2019 [
This global trend of e-commerce is forcing all businesses to go online, resulting in an increasing number of e-commerce stores. Each e-commerce store has different streams to publish an added item on the platform. Some markets, such as Amazon, eBay, etc., allow users to become sellers and add products themselves. This functionality permits retailers to increase the number of products they sell. However, the process of adding new products and assigning a category can lead to consistency issues. An error in the classification of the product in the first place can lead to some problems with finding the exact product. Therefore, the correct categorization of products is critical for all e-commerce platforms, as it speeds up the search for the definite product and provides better interaction with users, highlighting the correct categories.
To solve these problems with the assignment of goods to the wrong category, an automatic tool that can classify any product by name in the product taxonomy is needed. At the same time, this process will facilitate human work and further improve the consistency of product categorization on ecommerce websites.
In this paper, we apply some approaches to product categorization for the provided data collection. The data provided were taken from many different online stores. The total amount of data provided in the JSON file is over 40,000 lines. This number of records will allow us to teach the model to predict the category of goods for future products.
This section provides an overview of existing research on product classification based on product specifications that have been studied with different approaches and methods in recent years.
Due to not all websites use a hierarchy of product classification and some of them use but it can be completely different, a unified product classification from different websites is needed in order to provide the user with useful features like browsing and searching.
Although there are several approaches to product data classification [
Recently, the categorization of goods using product descriptions by Chen and Warren has aroused
great interest [
At an elevated level, the goal for our system is to build a multi-class classifier, which can accurately predict the product category of a new unlabeled product title. The high-level steps are presented in Figure 1. a. Removes topic-neutral words such as articles (a, an, the), prepositions (in, of, at), conjunctions (and, or, nor), etc. from the documents.
b. Word stemming models (K-NN).
Analysis of the results
The full process is described below. 3.1.
Classification models: Multi-Class SVM, K nearest neighbours (K-NN) for the selected features. These two models were selected to compare the discriminative (SVM) and nonparametric
The classifier is built basing on the learning from the provided dataset and can be used to classify unknown products by brand in future. We choose two algorithms (K-NN and SVM) to implement. We provide a brief description of each algorithm in this Section.
optimization problem [
SVM is introduced as an algorithm for text classification by Joachims [
⃗⃗ ∗ ⃗⃗ + ∑ =1 : ∀ =1: [⃗⃗
∗ ⃗⃗⃗⃗ + ] ≥ 1 − ∀ =1: > 0
The factor in (1) is a parameter used for trading off training error vs. model complexity. The constraints (2) require that all training instances be classified correctly up to some slack .
The K-Nearest Neighbour (K-NN) is one of the popular algorithms [
The algorithm assumes that it is possible to classify documents in the Euclidean space as points [
( , ) = ( , ) = √( − )2 + ( − )2 3.2.
First of all, it is necessary to convert the input format to CSV. This format is more common in Python and gives us more opportunities to work with data. (1) (2) (3) (4)
To do this, we installed an additional library of pandas. We did this with the following command: pip install pandas.
This library contains the read_json () method, which allows you to upload a file to the program and continue working with it. The read_json () method can take several parameters but we used only one: path_or_buf. This parameter is responsible for the path to our JSON file. This library contains the read_json() method, which allows you to upload a file to the program and continue working with it.
Once we download the file data to the program's memory, we can start working on it. The data downloaded to the program's memory can be written to a CSV file, using the following method to_csv(). In this method, we passed the path where we wanted to place our CSV file as a parameter.
The code needed to convert a file from JSON to CSV can be found in the convert.py script. Run the file with the following command: python convert.py.
After we have converted the input file, we can start its analysis. The input file contains 41,664 records and 17 columns:
Consider the source data contained in the tables. The data is presented in Figures 3 and 4.
We focused on each of the provided columns separately. This is important because a more detailed analysis allowed us to understand exactly how to configure the script for automatic data processing.
The amount of zero data in the tables was analysed, the result is presented in Figure 5.
Analysing Figure 5, we concluded that the data contains many zero values, but this function calculates the sum of zero values. Therefore, if there are no records in the column, the sum of the zero values will not be found correctly. The proof of this issue is presented in Figures 3 and 4 where we can see the empty columns. Thus, before deleting the null rows the additional manual examination for the columns is required. The result of our additional analysis is presented in Figure 6 3.3.
Based on the data analysis stage, we identified columns that were used for further modelling. Thus, for the machine learning model, we used: title, description, and brand. The example of the columns and the data they contain is presented in Figure 7.
Based on the provided example in Figure 6, we concluded that the existing data cannot be used for appropriate product categorization, because of the: a large number of empty values; data duplication.
Therefore, before approaching the categorization of data, we decided to proceed with further cleaning. So, we developed the component which cleans input data automatically. 3.4.
Since our solution in future will work with the new data itself, we developed a script that cleans the data automatically.
First of all, we removed cells that contain empty values. Otherwise, the algorithm cannot process the data correctly. To do this, we used the dropna() method that comes with the pandas() package. This method automatically deleted empty cells.
Next, duplicates are removed with the drop_duplicates() method. For this method to process the current file (and not return a new one), set the inplace = TRUE parameter. Since the input data will be obtained from several resources, we need to process them further.
The HTML tags were removed, as there was a risk that they might be in our sample. It was done using the methods BeautifulSoup() and get_test() from the bs4 library.
Then the special characters which could be in these data were removed. The library re and the sub() method were imported. As the first parameter, we passed the following pattern: [^ a-zA-Z \ d].
The next step was to transform all the text data into lowercase and broke it down into words. To do this we used two lower() and split() methods.
After that, the "stop words" can be applied, for that the stopwords() function was used. This function takes one argument: the language we work with. As this argument, we transferred the value "English feature". This set parameter analyzes the language in each cell and removes all non-English rows.
To start automatic cleaning of input data, you should run python clear.py script that contains all the steps described above. After executing the submitted script, our document contains 3 columns and 10,200 unique cleaned lines. An example of the processed data is shown in Figure 8.
Thus, after processing 41,664 lines, 10,200 lines were left, which is 24,48% of the initial dataset. 3.5.
Machine learning algorithms usual operate on a numeric feature space. To perform the algorithm on
the text, we transformed our text data into vector representations. It is called feature extraction or
vectorization [
In this paper, we evaluated performance of two methods HashingVectorizer, CountVectorize which are used for converting the collection of text data to a matrix of token counts and TfidfVectorizer method for converting a collection of raw data to a matrix of TF-IDF features.
HashingVectorizer and CountVectorizer are meant to do the same thing, which is to convert a
collection of text documents to a matrix of token occurrences. [
) (5) where is the weight of term in document , is the number of documents in the collection, is the term frequency of term in document and is the document frequency of term in the collection.
To obtain better results with documents of different length, we used a modified equation [
Each row is converted into appropriate representation and applied to training, validation, and The vectorization also allows us to calculate the number of unique categories which we are going to Both algorithms will process with the features selected in Section 3.3.
For selected, cleaned features we applied the vectorization CountVectorizer function which was done during applying the StratifiedKFold method which splits the dataset into the 3.6 test groups. The selected vectorization function allows us to evaluate the performance of the built model and compare the results we got with applying K-NN. After we applied the vectorization function, the next step was determining the optimal value of the C parameter. The evaluation for selected C parameters is presented in Section 3.7.1.
As we selected features, we vectorized the data. For the K-NN model, we evaluated the performance by applying each vectorizing functions described in Section 3.5. The evaluation is done in Section 3.7.2.
In the next step, we determined the K value. To determine the vectors distance between the data for K-NN, we used both Cosine similarity and Euclidean space. 3.7.
The method of stratified cross-validation kfold (Stratified kfold cross validation) was used to assess the quality of the model at the initial stage. Choosing between regular cross-checking kfold and stratified cross-checking. The kfold check selected a stratified kfold cross check. Because we have unbalanced data, stratified kfold cross-checking is useful for our experiment. It was decided not to use regular kfold cross-checking because we do not have enough data and this method often preserves the ratio of classes, and this can lead to partitioning in such a way that some networks will contain examples of training from only one class.
Stratified cross-checking is suitable for assessing the quality of a classifier without the use of test data. Testing occurs from parts of the training sample that are not known to the classifier. This assessment approach helps determine if the system is capable of relearning. In our experiment, we used a stratified cross-check with k bends (k = 6) for 10,200 products and 323 categories. Therefore, the evaluation was done for the 1703 products.
The evaluation was performed in several test phases: quality classification; speed text classification; classifications recall according to categories of product.
Classification results, reported in this section, were based on the evaluation which was done
according to F1–measure, precision, recall, and accuracy metrics [
We applied different values for the C parameter to ensure that the experimental results faithfully reflect the performance of the algorithms.
From the experimental result of the SVM, the C parameter equals 0,125 is optimal based on the execution time of 310.8 sec which is 5.5 min and the macro average for F1-score is 72%.
Also, for measuring the performance we calculated the number of goods with correct and incorrect classification based on that the percentage of correct and misclassified categories was found. So, the algorithm creates a separate file for initial and classified values, and automatically compares values. Then this function calculates the sum of correct and incorrect predicted values and percentage accordingly.
The output of this function is presented in Figure 8. The comparison is presented in Figure 10. As we selected features, we vectorized the data. For the K-NN model, we evaluated the performance by applying each vectorizing functions described in Section 3.5. The evaluation is done in Section 3.7.2.
In the next step, we determined the K value. K value of the K-NN algorithm is a factor that indicates a required amount of data from the collection which is closest to the selected row. To determine the vectors distance between the data for K-NN, we used both Cosine similarity and Euclidean space.
Various scaling methods were used to evaluate the efficiency of the model, such as the similarity of cosines and Euclidean space. The final analysis of the model efficiency is analyzed based on the chosen method. Figures 11-13 represent some results of our experimets.
Based on the K-NN models evaluation results, the best result for classification by a brand we got while using the vectorization method TfidfVectorizer and cosine similarity metric, where the macro average for F1 is 70%. The number of goods with correct and incorrect classification and the percentage of correct and misclassified categories were calculated as the same for SVM presented in Figure 10.
Also, we can see that the execution time which is 9,04 sec for the best result depends on the selected scale method, metrics and the number of features used for the elevation.
Therefore, we can conclude that if the number of input features is increased, the execution time could become critical, and another faster model can be used.
In this paper, we present an investigation of two widely used approaches for text categorization KNN and the SVM algorithms.
The main goal of the research was to evaluate the performance of two popular K-NN and SVM algorithms, compare execution time for both of them and to develop an MVP pipeline that can automatically classify the shoes category based on the brand.
The combination of the K-NN algorithm and different vectorization methods showed good results as well as SVM and CountVectorizer. However, despite the good performance results of the SVM algorithm, it has the highest execution time, which can be significant for big marketplaces.
Therefore, the gained results which are reported in this paper are satisfactory, however, they are not the best that can be achieved. Moreover, additional investigation is needed to improve the performance of applied algorithms.
To further study and improve the model, the following steps are suggested: - Get more data to test models; - Implement of the algorithm for automatic search of optimal arameters;
Prepare the developed module for integration with e-commerce stores.