Skip to content
BranchesTags

Repository files navigation

Backorder Prediction - Django Web Application

This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.

Table of Contents

Installation and Usage

Cloning the Project

To clone this project, run the following command in your terminal:

git clone https://github.com/Pradyothsp/backorder-prediction.git

Creating Virtual Environment

python3 -m venv venv
source venv/bin/activate

Getting Started

Navigate to the project directory and follow the steps below to set up and run the project locally:

cd app

  1. Install the required dependencies by running the following command:

    pip install -r requirements/local.txt

  2. Run the Django migrations to set up the database:

    python3 manage.py makemigrations
python3 manage.py migrate

  3. Start the Django development server:

    python3 manage.py runserver

  4. Open your web browser and navigate to http://localhost:8000/ to view the application.

    The application has a simple web interface where you can input the product features and get a prediction on whether the product will go on backorder or not.

    You can also make predictions using the API endpoint by sending a POST request to http://localhost:8000/predict/ with a JSON payload containing the product features.

Features

  • Backorder Prediction: Predict whether a product will go on backorder or not based on various features.
  • Batch Prediction: Provide a CSV file containing multiple product records for batch prediction of backorder status.
  • Single Product Prediction: Offer a form interface to input the features of a single product and obtain a prediction on its backorder status.

Result

The table below shows the performance metrics of different models on the backorder prediction task. The models evaluated are Decision Tree, Random Forest, and Light GBM. The dataset used for evaluation consists of train, validation, and test sets.

ModelData SetAccuracyRecallPrecision
Decision TreeTrain0.9460.96510.9814
Valid0.88180.90790.8445
Test0.86330.80650.0605
Random ForestTrain0.99810.99820.9998
Valid0.91940.95130.9727
Test0.90030.80770.1878
Light GBMTrain0.99410.99540.9997
Valid0.92210.95130.9675
Test0.90690.79390.2052

Screenshots

Home Page:

Home Page

Predict:

Predict

Result (Single Product Prediction):

Single Product Prediction

Result (Batch Prediction):

Batch Prediction

Development

This application was developed using Django 4.2. The backorder prediction model was trained using scikit-learn and is stored in the backorder/model/backorder_best_model.pkl file.

To train a new prediction model, you can run the model.ipynb Jupyter Notebook in the root directory.

License

Backorder Prediction is licensed under the Apache License 2.0. See the LICENSE file for details.

The Apache License 2.0 is a permissive open source license that grants permissions to use, copy, modify, and distribute the software. It includes limitations on liability and requires that any modified or redistributed versions of the software be accompanied by a prominent notice stating the changes made.

You can find more information about the Apache License 2.0 here.

Credits

This project was created by Pradyoth S P.

The backorder dataset used to train the prediction model is from the Kaggle.

About

This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.

Topics

backordersdecision-tree-classifierdjango-projectlgbmrandom-forest-classifier

Resources

Readme
Apache-2.0 license
Activity

Stars

0 stars

Watchers

1 watching

Forks

2 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - Pradyothsp/backorder-prediction: This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder Prediction - Django Web Application
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Table of Contents
Installation and Usage
Cloning the Project
To clone this project, run the following command in your terminal:
git clone https://github.com/Pradyothsp/backorder-prediction.git
Creating Virtual Environment
python3 -m venv venv
source venv/bin/activate
Getting Started
Navigate to the project directory and follow the steps below to set up and run the project locally:
cd app
  1. Install the required dependencies by running the following command:
    pip install -r requirements/local.txt
  2. Run the Django migrations to set up the database:
    python3 manage.py makemigrations
python3 manage.py migrate
  3. Start the Django development server:
    python3 manage.py runserver
  4. Open your web browser and navigate to http://localhost:8000/ to view the application.
    The application has a simple web interface where you can input the product features and get a prediction on whether the product will go on backorder or not.
    You can also make predictions using the API endpoint by sending a POST request to http://localhost:8000/predict/ with a JSON payload containing the product features.
Features
  • Backorder Prediction: Predict whether a product will go on backorder or not based on various features.
  • Batch Prediction: Provide a CSV file containing multiple product records for batch prediction of backorder status.
  • Single Product Prediction: Offer a form interface to input the features of a single product and obtain a prediction on its backorder status.
Result
The table below shows the performance metrics of different models on the backorder prediction task. The models evaluated are Decision Tree, Random Forest, and Light GBM. The dataset used for evaluation consists of train, validation, and test sets.
ModelData SetAccuracyRecallPrecision
Decision TreeTrain0.9460.96510.9814
Valid0.88180.90790.8445
Test0.86330.80650.0605
Random ForestTrain0.99810.99820.9998
Valid0.91940.95130.9727
Test0.90030.80770.1878
Light GBMTrain0.99410.99540.9997
Valid0.92210.95130.9675
Test0.90690.79390.2052
Screenshots
Home Page:
Home Page
Predict:
Predict
Result (Single Product Prediction):
Single Product Prediction
Result (Batch Prediction):
Batch Prediction
Development
This application was developed using Django 4.2. The backorder prediction model was trained using scikit-learn and is stored in the backorder/model/backorder_best_model.pkl file.
To train a new prediction model, you can run the model.ipynb Jupyter Notebook in the root directory.
License
Backorder Prediction is licensed under the Apache License 2.0. See the LICENSE file for details.
The Apache License 2.0 is a permissive open source license that grants permissions to use, copy, modify, and distribute the software. It includes limitations on liability and requires that any modified or redistributed versions of the software be accompanied by a prominent notice stating the changes made.
You can find more information about the Apache License 2.0 here.
Credits
This project was created by Pradyoth S P.
The backorder dataset used to train the prediction model is from the Kaggle.
About
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Topics
backordersdecision-tree-classifierdjango-projectlgbmrandom-forest-classifier
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Pradyothsp/backorder-prediction: This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder Prediction - Django Web Application
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Table of Contents
Installation and Usage
Cloning the Project
To clone this project, run the following command in your terminal:
git clone https://github.com/Pradyothsp/backorder-prediction.git
Creating Virtual Environment
python3 -m venv venv
source venv/bin/activate
Getting Started
Navigate to the project directory and follow the steps below to set up and run the project locally:
cd app
  1. Install the required dependencies by running the following command:
    pip install -r requirements/local.txt
  2. Run the Django migrations to set up the database:
    python3 manage.py makemigrations
python3 manage.py migrate
  3. Start the Django development server:
    python3 manage.py runserver
  4. Open your web browser and navigate to http://localhost:8000/ to view the application.
    The application has a simple web interface where you can input the product features and get a prediction on whether the product will go on backorder or not.
    You can also make predictions using the API endpoint by sending a POST request to http://localhost:8000/predict/ with a JSON payload containing the product features.
Features
  • Backorder Prediction: Predict whether a product will go on backorder or not based on various features.
  • Batch Prediction: Provide a CSV file containing multiple product records for batch prediction of backorder status.
  • Single Product Prediction: Offer a form interface to input the features of a single product and obtain a prediction on its backorder status.
Result
The table below shows the performance metrics of different models on the backorder prediction task. The models evaluated are Decision Tree, Random Forest, and Light GBM. The dataset used for evaluation consists of train, validation, and test sets.
ModelData SetAccuracyRecallPrecision
Decision TreeTrain0.9460.96510.9814
Valid0.88180.90790.8445
Test0.86330.80650.0605
Random ForestTrain0.99810.99820.9998
Valid0.91940.95130.9727
Test0.90030.80770.1878
Light GBMTrain0.99410.99540.9997
Valid0.92210.95130.9675
Test0.90690.79390.2052
Screenshots
Home Page:
Home Page
Predict:
Predict
Result (Single Product Prediction):
Single Product Prediction
Result (Batch Prediction):
Batch Prediction
Development
This application was developed using Django 4.2. The backorder prediction model was trained using scikit-learn and is stored in the backorder/model/backorder_best_model.pkl file.
To train a new prediction model, you can run the model.ipynb Jupyter Notebook in the root directory.
License
Backorder Prediction is licensed under the Apache License 2.0. See the LICENSE file for details.
The Apache License 2.0 is a permissive open source license that grants permissions to use, copy, modify, and distribute the software. It includes limitations on liability and requires that any modified or redistributed versions of the software be accompanied by a prominent notice stating the changes made.
You can find more information about the Apache License 2.0 here.
Credits
This project was created by Pradyoth S P.
The backorder dataset used to train the prediction model is from the Kaggle.
About
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Topics
backordersdecision-tree-classifierdjango-projectlgbmrandom-forest-classifier
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Pradyothsp/backorder-prediction: This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder Prediction - Django Web Application
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Table of Contents
Installation and Usage
Cloning the Project
To clone this project, run the following command in your terminal:
git clone https://github.com/Pradyothsp/backorder-prediction.git
Creating Virtual Environment
python3 -m venv venv
source venv/bin/activate
Getting Started
Navigate to the project directory and follow the steps below to set up and run the project locally:
cd app
  1. Install the required dependencies by running the following command:
    pip install -r requirements/local.txt
  2. Run the Django migrations to set up the database:
    python3 manage.py makemigrations
python3 manage.py migrate
  3. Start the Django development server:
    python3 manage.py runserver
  4. Open your web browser and navigate to http://localhost:8000/ to view the application.
    The application has a simple web interface where you can input the product features and get a prediction on whether the product will go on backorder or not.
    You can also make predictions using the API endpoint by sending a POST request to http://localhost:8000/predict/ with a JSON payload containing the product features.
Features
  • Backorder Prediction: Predict whether a product will go on backorder or not based on various features.
  • Batch Prediction: Provide a CSV file containing multiple product records for batch prediction of backorder status.
  • Single Product Prediction: Offer a form interface to input the features of a single product and obtain a prediction on its backorder status.
Result
The table below shows the performance metrics of different models on the backorder prediction task. The models evaluated are Decision Tree, Random Forest, and Light GBM. The dataset used for evaluation consists of train, validation, and test sets.
ModelData SetAccuracyRecallPrecision
Decision TreeTrain0.9460.96510.9814
Valid0.88180.90790.8445
Test0.86330.80650.0605
Random ForestTrain0.99810.99820.9998
Valid0.91940.95130.9727
Test0.90030.80770.1878
Light GBMTrain0.99410.99540.9997
Valid0.92210.95130.9675
Test0.90690.79390.2052
Screenshots
Home Page:
Home Page
Predict:
Predict
Result (Single Product Prediction):
Single Product Prediction
Result (Batch Prediction):
Batch Prediction
Development
This application was developed using Django 4.2. The backorder prediction model was trained using scikit-learn and is stored in the backorder/model/backorder_best_model.pkl file.
To train a new prediction model, you can run the model.ipynb Jupyter Notebook in the root directory.
License
Backorder Prediction is licensed under the Apache License 2.0. See the LICENSE file for details.
The Apache License 2.0 is a permissive open source license that grants permissions to use, copy, modify, and distribute the software. It includes limitations on liability and requires that any modified or redistributed versions of the software be accompanied by a prominent notice stating the changes made.
You can find more information about the Apache License 2.0 here.
Credits
This project was created by Pradyoth S P.
The backorder dataset used to train the prediction model is from the Kaggle.
About
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Topics
backordersdecision-tree-classifierdjango-projectlgbmrandom-forest-classifier
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - Pradyothsp/backorder-prediction: This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder Prediction - Django Web Application
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Table of Contents
Installation and Usage
Cloning the Project
To clone this project, run the following command in your terminal:
git clone https://github.com/Pradyothsp/backorder-prediction.git
Creating Virtual Environment
python3 -m venv venv
source venv/bin/activate
Getting Started
Navigate to the project directory and follow the steps below to set up and run the project locally:
cd app
  1. Install the required dependencies by running the following command:
    pip install -r requirements/local.txt
  2. Run the Django migrations to set up the database:
    python3 manage.py makemigrations
python3 manage.py migrate
  3. Start the Django development server:
    python3 manage.py runserver
  4. Open your web browser and navigate to http://localhost:8000/ to view the application.
    The application has a simple web interface where you can input the product features and get a prediction on whether the product will go on backorder or not.
    You can also make predictions using the API endpoint by sending a POST request to http://localhost:8000/predict/ with a JSON payload containing the product features.
Features
  • Backorder Prediction: Predict whether a product will go on backorder or not based on various features.
  • Batch Prediction: Provide a CSV file containing multiple product records for batch prediction of backorder status.
  • Single Product Prediction: Offer a form interface to input the features of a single product and obtain a prediction on its backorder status.
Result
The table below shows the performance metrics of different models on the backorder prediction task. The models evaluated are Decision Tree, Random Forest, and Light GBM. The dataset used for evaluation consists of train, validation, and test sets.
ModelData SetAccuracyRecallPrecision
Decision TreeTrain0.9460.96510.9814
Valid0.88180.90790.8445
Test0.86330.80650.0605
Random ForestTrain0.99810.99820.9998
Valid0.91940.95130.9727
Test0.90030.80770.1878
Light GBMTrain0.99410.99540.9997
Valid0.92210.95130.9675
Test0.90690.79390.2052
Screenshots
Home Page:
Home Page
Predict:
Predict
Result (Single Product Prediction):
Single Product Prediction
Result (Batch Prediction):
Batch Prediction
Development
This application was developed using Django 4.2. The backorder prediction model was trained using scikit-learn and is stored in the backorder/model/backorder_best_model.pkl file.
To train a new prediction model, you can run the model.ipynb Jupyter Notebook in the root directory.
License
Backorder Prediction is licensed under the Apache License 2.0. See the LICENSE file for details.
The Apache License 2.0 is a permissive open source license that grants permissions to use, copy, modify, and distribute the software. It includes limitations on liability and requires that any modified or redistributed versions of the software be accompanied by a prominent notice stating the changes made.
You can find more information about the Apache License 2.0 here.
Credits
This project was created by Pradyoth S P.
The backorder dataset used to train the prediction model is from the Kaggle.
About
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Topics
backordersdecision-tree-classifierdjango-projectlgbmrandom-forest-classifier
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Pradyothsp/backorder-prediction: This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder Prediction - Django Web Application
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Table of Contents
Installation and Usage
Cloning the Project
To clone this project, run the following command in your terminal:
git clone https://github.com/Pradyothsp/backorder-prediction.git
Creating Virtual Environment
python3 -m venv venv
source venv/bin/activate
Getting Started
Navigate to the project directory and follow the steps below to set up and run the project locally:
cd app
  1. Install the required dependencies by running the following command:
    pip install -r requirements/local.txt
  2. Run the Django migrations to set up the database:
    python3 manage.py makemigrations
python3 manage.py migrate
  3. Start the Django development server:
    python3 manage.py runserver
  4. Open your web browser and navigate to http://localhost:8000/ to view the application.
    The application has a simple web interface where you can input the product features and get a prediction on whether the product will go on backorder or not.
    You can also make predictions using the API endpoint by sending a POST request to http://localhost:8000/predict/ with a JSON payload containing the product features.
Features
  • Backorder Prediction: Predict whether a product will go on backorder or not based on various features.
  • Batch Prediction: Provide a CSV file containing multiple product records for batch prediction of backorder status.
  • Single Product Prediction: Offer a form interface to input the features of a single product and obtain a prediction on its backorder status.
Result
The table below shows the performance metrics of different models on the backorder prediction task. The models evaluated are Decision Tree, Random Forest, and Light GBM. The dataset used for evaluation consists of train, validation, and test sets.
ModelData SetAccuracyRecallPrecision
Decision TreeTrain0.9460.96510.9814
Valid0.88180.90790.8445
Test0.86330.80650.0605
Random ForestTrain0.99810.99820.9998
Valid0.91940.95130.9727
Test0.90030.80770.1878
Light GBMTrain0.99410.99540.9997
Valid0.92210.95130.9675
Test0.90690.79390.2052
Screenshots
Home Page:
Home Page
Predict:
Predict
Result (Single Product Prediction):
Single Product Prediction
Result (Batch Prediction):
Batch Prediction
Development
This application was developed using Django 4.2. The backorder prediction model was trained using scikit-learn and is stored in the backorder/model/backorder_best_model.pkl file.
To train a new prediction model, you can run the model.ipynb Jupyter Notebook in the root directory.
License
Backorder Prediction is licensed under the Apache License 2.0. See the LICENSE file for details.
The Apache License 2.0 is a permissive open source license that grants permissions to use, copy, modify, and distribute the software. It includes limitations on liability and requires that any modified or redistributed versions of the software be accompanied by a prominent notice stating the changes made.
You can find more information about the Apache License 2.0 here.
Credits
This project was created by Pradyoth S P.
The backorder dataset used to train the prediction model is from the Kaggle.
About
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Topics
backordersdecision-tree-classifierdjango-projectlgbmrandom-forest-classifier
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - Pradyothsp/backorder-prediction: This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder Prediction - Django Web Application
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Table of Contents
Installation and Usage
Cloning the Project
To clone this project, run the following command in your terminal:
git clone https://github.com/Pradyothsp/backorder-prediction.git
Creating Virtual Environment
python3 -m venv venv
source venv/bin/activate
Getting Started
Navigate to the project directory and follow the steps below to set up and run the project locally:
cd app
  1. Install the required dependencies by running the following command:
    pip install -r requirements/local.txt
  2. Run the Django migrations to set up the database:
    python3 manage.py makemigrations
python3 manage.py migrate
  3. Start the Django development server:
    python3 manage.py runserver
  4. Open your web browser and navigate to http://localhost:8000/ to view the application.
    The application has a simple web interface where you can input the product features and get a prediction on whether the product will go on backorder or not.
    You can also make predictions using the API endpoint by sending a POST request to http://localhost:8000/predict/ with a JSON payload containing the product features.
Features
  • Backorder Prediction: Predict whether a product will go on backorder or not based on various features.
  • Batch Prediction: Provide a CSV file containing multiple product records for batch prediction of backorder status.
  • Single Product Prediction: Offer a form interface to input the features of a single product and obtain a prediction on its backorder status.
Result
The table below shows the performance metrics of different models on the backorder prediction task. The models evaluated are Decision Tree, Random Forest, and Light GBM. The dataset used for evaluation consists of train, validation, and test sets.
ModelData SetAccuracyRecallPrecision
Decision TreeTrain0.9460.96510.9814
Valid0.88180.90790.8445
Test0.86330.80650.0605
Random ForestTrain0.99810.99820.9998
Valid0.91940.95130.9727
Test0.90030.80770.1878
Light GBMTrain0.99410.99540.9997
Valid0.92210.95130.9675
Test0.90690.79390.2052
Screenshots
Home Page:
Home Page
Predict:
Predict
Result (Single Product Prediction):
Single Product Prediction
Result (Batch Prediction):
Batch Prediction
Development
This application was developed using Django 4.2. The backorder prediction model was trained using scikit-learn and is stored in the backorder/model/backorder_best_model.pkl file.
To train a new prediction model, you can run the model.ipynb Jupyter Notebook in the root directory.
License
Backorder Prediction is licensed under the Apache License 2.0. See the LICENSE file for details.
The Apache License 2.0 is a permissive open source license that grants permissions to use, copy, modify, and distribute the software. It includes limitations on liability and requires that any modified or redistributed versions of the software be accompanied by a prominent notice stating the changes made.
You can find more information about the Apache License 2.0 here.
Credits
This project was created by Pradyoth S P.
The backorder dataset used to train the prediction model is from the Kaggle.
About
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Topics
backordersdecision-tree-classifierdjango-projectlgbmrandom-forest-classifier
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - Pradyothsp/backorder-prediction: This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder Prediction - Django Web Application
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Table of Contents
Installation and Usage
Cloning the Project
To clone this project, run the following command in your terminal:
git clone https://github.com/Pradyothsp/backorder-prediction.git
Creating Virtual Environment
python3 -m venv venv
source venv/bin/activate
Getting Started
Navigate to the project directory and follow the steps below to set up and run the project locally:
cd app
  1. Install the required dependencies by running the following command:
    pip install -r requirements/local.txt
  2. Run the Django migrations to set up the database:
    python3 manage.py makemigrations
python3 manage.py migrate
  3. Start the Django development server:
    python3 manage.py runserver
  4. Open your web browser and navigate to http://localhost:8000/ to view the application.
    The application has a simple web interface where you can input the product features and get a prediction on whether the product will go on backorder or not.
    You can also make predictions using the API endpoint by sending a POST request to http://localhost:8000/predict/ with a JSON payload containing the product features.
Features
  • Backorder Prediction: Predict whether a product will go on backorder or not based on various features.
  • Batch Prediction: Provide a CSV file containing multiple product records for batch prediction of backorder status.
  • Single Product Prediction: Offer a form interface to input the features of a single product and obtain a prediction on its backorder status.
Result
The table below shows the performance metrics of different models on the backorder prediction task. The models evaluated are Decision Tree, Random Forest, and Light GBM. The dataset used for evaluation consists of train, validation, and test sets.
ModelData SetAccuracyRecallPrecision
Decision TreeTrain0.9460.96510.9814
Valid0.88180.90790.8445
Test0.86330.80650.0605
Random ForestTrain0.99810.99820.9998
Valid0.91940.95130.9727
Test0.90030.80770.1878
Light GBMTrain0.99410.99540.9997
Valid0.92210.95130.9675
Test0.90690.79390.2052
Screenshots
Home Page:
Home Page
Predict:
Predict
Result (Single Product Prediction):
Single Product Prediction
Result (Batch Prediction):
Batch Prediction
Development
This application was developed using Django 4.2. The backorder prediction model was trained using scikit-learn and is stored in the backorder/model/backorder_best_model.pkl file.
To train a new prediction model, you can run the model.ipynb Jupyter Notebook in the root directory.
License
Backorder Prediction is licensed under the Apache License 2.0. See the LICENSE file for details.
The Apache License 2.0 is a permissive open source license that grants permissions to use, copy, modify, and distribute the software. It includes limitations on liability and requires that any modified or redistributed versions of the software be accompanied by a prominent notice stating the changes made.
You can find more information about the Apache License 2.0 here.
Credits
This project was created by Pradyoth S P.
The backorder dataset used to train the prediction model is from the Kaggle.
About
This is a Django web application that uses machine learning to predict whether a product will go on backorder or not. It uses a pre-trained Random Forest Classifier, Decision Tree and LGBM models to make predictions based on various features such as product availability, lead time, and more.
Topics
backordersdecision-tree-classifierdjango-projectlgbmrandom-forest-classifier
Resources
Readme
Apache-2.0 license
Activity
Stars
0 stars
Watchers
1 watching
Forks
2 forks
Report repository
Releases
Packages
Contributors
Languages