Skip to content
BranchesTags

Repository files navigation

Backorder-prediction ❗

Backorder is an order which can’t be fulfilled at the given time due to lack of supply or the product is currently out of stock or not in inventory but can guarantee delivery of the goods or service requested by a certain date in the future because the production of goods or replenishment of inventory is underway. Unlike in the situation of Out-of-stock where the delivery date of the goods can’t be promised , in the Backorder scenario the customers are allowed to shop for the products and order. Simply put Backorder can be thought of as an order with a delayed delivery date.

Backorders are unavoidable, but by anticipating which things will be backordered, planning can be streamlined at several levels, preventing unexpected strain on production, logistics, and transportation. ERP systems generate a lot of data (mainly structured) and also contain a lot of historical data; if this data can be properly utilized, a predictive model to forecast backorders and plan accordingly can be constructed. Based on past data from inventories, supply chain, and sales, classify the products as going into backorder (Yes or No).

Data Analysis

In the Train dataset we are provided with 23 columns(Features) of data.

  • Sku(Stock Keeping unit) : The product id — Unique for each row so can be ignored
  • National_inv : The present inventory level of the product
  • Lead_time : Transit time of the product
  • In_transit_qty : The amount of product in transit
  • Forecast_3_month , Forecast_6_month , Forecast_9_month : Forecast of the sales of the product for coming 3 , 6 and 9 months respectively
  • Sales_1_month , sales_3_month ,sales_6_month , sales_9_month : Actual sales of the product in last 1 , 3 ,6 and 9 months respectively
  • Min_bank : Minimum amount of stock recommended
  • Potential_issue : Any problem identified in the product/part
  • Pieces_past_due: Amount of parts of the product overdue if any
  • Perf_6_month_avg , perf_12_month_avg : Product performance over past 6 and 12 months respectively
  • Local_bo_qty : Amount of stock overdue
  • Deck_risk , oe_constraint, ppap_risk, stop_auto_buy, rev_stop : Different Flags (Yes or No) set for the product
  • Went_on_backorder : Target variable

Out of the 23 features given in the dataset 15 are numerical and 8(including the target variable) are categorical features.

User InterFace

  • Home Page

  • Predict Page

Approach

The main goal is to predict the whether a product comes in backorder or not based on different factors available in the dataset.

  • Data Exploration : Exploring dataset using pandas,numpy,matplotlib and seaborn.
  • Data visualization : Ploted graphs to get insights about dependend and independed variables.
  • Feature Engineering : Removed missing values and created new features as per insights.
  • Model Selection I : Tested all base models to check the base accuracy. Also ploted and calculate Performance Metrics to check whether a model is a good fit or not.
  • Model Selection II : Performed Hyperparameter tuning using RandomsearchCV.
  • Pickle File : Selected model as per best accuracy and created pickle file using pickle library.
  • Webpage & deployment : Created a webform that takes all the necessary inputs from user and shows output. After that I have deployed project on AWS .

Technologies Used

  • VS-Code Is Used For IDE.
  • For Visualization Of The Plots Matplotlib , Seaborn Are Used.
  • Heroku is Used For Model Deployment.
  • mongoDB Database Is Used To As Data Base.
  • Front End Deployment Is Done Using HTML , CSS.
  • Flask is for creating the application server and pages.
  • Git Hub Is Used As A Version Control System.
  • josn is for data validation processes.
  • os is used for creating and deleting folders.
  • csv is used for creating .csv format file.
  • numpy is for arrays computations and mathematical operations
  • pandas is for Manipulation and wrangling structured data
  • scikit-learn is used for machine learning tool kit
  • pickle is used for saving model
  • XgBoost is used for XgBoostClassifier Implementation.
  • Nearmiss Imbalance is used for handling Imbalance Data.

Run Locally

  • Clone the project
 git clone https://github.com/umangtank/BackOrder
  • Go to the project directory
cd BackOrder
  • Install dependencies
pip install -r requirements.txt
  • Run the app.py
 python app.py

Usage

In Development If You Want to contribute? Great!

To fix a bug or enhance an existing module, follow these steps:

  • Fork the repo

  • Create a new branch

 git checkout -b new-feature

  • Make the appropriate changes in the file

  • Commit your changes

 git commit -m "New feature added"
  • Push to the branch
 git push origin new-feature
  • Create a pull request

Help Me Improve

Hello Reader if you find any bug please consider raising issue I will address them asap.

About

Predicting Backorders using Machine Learning.

Topics

backordersdata-sciencemachine-learning

Resources

Readme
GPL-3.0 license
Activity

Stars

5 stars

Watchers

1 watching

Forks

0 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 - umangtank/BackOrder: Predicting Backorders using Machine Learning. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder-prediction ❗

Backorder is an order which can’t be fulfilled at the given time due to lack of supply or the product is currently out of stock or not in inventory but can guarantee delivery of the goods or service requested by a certain date in the future because the production of goods or replenishment of inventory is underway. Unlike in the situation of Out-of-stock where the delivery date of the goods can’t be promised , in the Backorder scenario the customers are allowed to shop for the products and order. Simply put Backorder can be thought of as an order with a delayed delivery date.


Backorders are unavoidable, but by anticipating which things will be backordered, planning can be streamlined at several levels, preventing unexpected strain on production, logistics, and transportation. ERP systems generate a lot of data (mainly structured) and also contain a lot of historical data; if this data can be properly utilized, a predictive model to forecast backorders and plan accordingly can be constructed. Based on past data from inventories, supply chain, and sales, classify the products as going into backorder (Yes or No).

Data Analysis
In the Train dataset we are provided with 23 columns(Features) of data.
  • Sku(Stock Keeping unit) : The product id — Unique for each row so can be ignored
  • National_inv : The present inventory level of the product
  • Lead_time : Transit time of the product
  • In_transit_qty : The amount of product in transit
  • Forecast_3_month , Forecast_6_month , Forecast_9_month : Forecast of the sales of the product for coming 3 , 6 and 9 months respectively
  • Sales_1_month , sales_3_month ,sales_6_month , sales_9_month : Actual sales of the product in last 1 , 3 ,6 and 9 months respectively
  • Min_bank : Minimum amount of stock recommended
  • Potential_issue : Any problem identified in the product/part
  • Pieces_past_due: Amount of parts of the product overdue if any
  • Perf_6_month_avg , perf_12_month_avg : Product performance over past 6 and 12 months respectively
  • Local_bo_qty : Amount of stock overdue
  • Deck_risk , oe_constraint, ppap_risk, stop_auto_buy, rev_stop : Different Flags (Yes or No) set for the product
  • Went_on_backorder : Target variable
Out of the 23 features given in the dataset 15 are numerical and 8(including the target variable) are categorical features.
User InterFace
  • Home Page
  • Predict Page
Approach
The main goal is to predict the whether a product comes in backorder or not based on different factors available in the dataset.
  • Data Exploration : Exploring dataset using pandas,numpy,matplotlib and seaborn.
  • Data visualization : Ploted graphs to get insights about dependend and independed variables.
  • Feature Engineering : Removed missing values and created new features as per insights.
  • Model Selection I : Tested all base models to check the base accuracy. Also ploted and calculate Performance Metrics to check whether a model is a good fit or not.
  • Model Selection II : Performed Hyperparameter tuning using RandomsearchCV.
  • Pickle File : Selected model as per best accuracy and created pickle file using pickle library.
  • Webpage & deployment : Created a webform that takes all the necessary inputs from user and shows output. After that I have deployed project on AWS .
Technologies Used
  • VS-Code Is Used For IDE.
  • For Visualization Of The Plots Matplotlib , Seaborn Are Used.
  • Heroku is Used For Model Deployment.
  • mongoDB Database Is Used To As Data Base.
  • Front End Deployment Is Done Using HTML , CSS.
  • Flask is for creating the application server and pages.
  • Git Hub Is Used As A Version Control System.
  • josn is for data validation processes.
  • os is used for creating and deleting folders.
  • csv is used for creating .csv format file.
  • numpy is for arrays computations and mathematical operations
  • pandas is for Manipulation and wrangling structured data
  • scikit-learn is used for machine learning tool kit
  • pickle is used for saving model
  • XgBoost is used for XgBoostClassifier Implementation.
  • Nearmiss Imbalance is used for handling Imbalance Data.
Run Locally
  • Clone the project
 git clone https://github.com/umangtank/BackOrder
  • Go to the project directory
cd BackOrder
  • Install dependencies
pip install -r requirements.txt
  • Run the app.py
 python app.py
Usage
In Development If You Want to contribute? Great!
To fix a bug or enhance an existing module, follow these steps:
  • Fork the repo
  • Create a new branch
 git checkout -b new-feature
  • Make the appropriate changes in the file
  • Commit your changes
 git commit -m "New feature added"
  • Push to the branch
 git push origin new-feature
  • Create a pull request
Help Me Improve
Hello Reader if you find any bug please consider raising issue I will address them asap.
About
Predicting Backorders using Machine Learning.
Topics
backordersdata-sciencemachine-learning
Resources
Readme
GPL-3.0 license
Activity
Stars
5 stars
Watchers
1 watching
Forks
0 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 - umangtank/BackOrder: Predicting Backorders using Machine Learning. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder-prediction ❗

Backorder is an order which can’t be fulfilled at the given time due to lack of supply or the product is currently out of stock or not in inventory but can guarantee delivery of the goods or service requested by a certain date in the future because the production of goods or replenishment of inventory is underway. Unlike in the situation of Out-of-stock where the delivery date of the goods can’t be promised , in the Backorder scenario the customers are allowed to shop for the products and order. Simply put Backorder can be thought of as an order with a delayed delivery date.


Backorders are unavoidable, but by anticipating which things will be backordered, planning can be streamlined at several levels, preventing unexpected strain on production, logistics, and transportation. ERP systems generate a lot of data (mainly structured) and also contain a lot of historical data; if this data can be properly utilized, a predictive model to forecast backorders and plan accordingly can be constructed. Based on past data from inventories, supply chain, and sales, classify the products as going into backorder (Yes or No).

Data Analysis
In the Train dataset we are provided with 23 columns(Features) of data.
  • Sku(Stock Keeping unit) : The product id — Unique for each row so can be ignored
  • National_inv : The present inventory level of the product
  • Lead_time : Transit time of the product
  • In_transit_qty : The amount of product in transit
  • Forecast_3_month , Forecast_6_month , Forecast_9_month : Forecast of the sales of the product for coming 3 , 6 and 9 months respectively
  • Sales_1_month , sales_3_month ,sales_6_month , sales_9_month : Actual sales of the product in last 1 , 3 ,6 and 9 months respectively
  • Min_bank : Minimum amount of stock recommended
  • Potential_issue : Any problem identified in the product/part
  • Pieces_past_due: Amount of parts of the product overdue if any
  • Perf_6_month_avg , perf_12_month_avg : Product performance over past 6 and 12 months respectively
  • Local_bo_qty : Amount of stock overdue
  • Deck_risk , oe_constraint, ppap_risk, stop_auto_buy, rev_stop : Different Flags (Yes or No) set for the product
  • Went_on_backorder : Target variable
Out of the 23 features given in the dataset 15 are numerical and 8(including the target variable) are categorical features.
User InterFace
  • Home Page
  • Predict Page
Approach
The main goal is to predict the whether a product comes in backorder or not based on different factors available in the dataset.
  • Data Exploration : Exploring dataset using pandas,numpy,matplotlib and seaborn.
  • Data visualization : Ploted graphs to get insights about dependend and independed variables.
  • Feature Engineering : Removed missing values and created new features as per insights.
  • Model Selection I : Tested all base models to check the base accuracy. Also ploted and calculate Performance Metrics to check whether a model is a good fit or not.
  • Model Selection II : Performed Hyperparameter tuning using RandomsearchCV.
  • Pickle File : Selected model as per best accuracy and created pickle file using pickle library.
  • Webpage & deployment : Created a webform that takes all the necessary inputs from user and shows output. After that I have deployed project on AWS .
Technologies Used
  • VS-Code Is Used For IDE.
  • For Visualization Of The Plots Matplotlib , Seaborn Are Used.
  • Heroku is Used For Model Deployment.
  • mongoDB Database Is Used To As Data Base.
  • Front End Deployment Is Done Using HTML , CSS.
  • Flask is for creating the application server and pages.
  • Git Hub Is Used As A Version Control System.
  • josn is for data validation processes.
  • os is used for creating and deleting folders.
  • csv is used for creating .csv format file.
  • numpy is for arrays computations and mathematical operations
  • pandas is for Manipulation and wrangling structured data
  • scikit-learn is used for machine learning tool kit
  • pickle is used for saving model
  • XgBoost is used for XgBoostClassifier Implementation.
  • Nearmiss Imbalance is used for handling Imbalance Data.
Run Locally
  • Clone the project
 git clone https://github.com/umangtank/BackOrder
  • Go to the project directory
cd BackOrder
  • Install dependencies
pip install -r requirements.txt
  • Run the app.py
 python app.py
Usage
In Development If You Want to contribute? Great!
To fix a bug or enhance an existing module, follow these steps:
  • Fork the repo
  • Create a new branch
 git checkout -b new-feature
  • Make the appropriate changes in the file
  • Commit your changes
 git commit -m "New feature added"
  • Push to the branch
 git push origin new-feature
  • Create a pull request
Help Me Improve
Hello Reader if you find any bug please consider raising issue I will address them asap.
About
Predicting Backorders using Machine Learning.
Topics
backordersdata-sciencemachine-learning
Resources
Readme
GPL-3.0 license
Activity
Stars
5 stars
Watchers
1 watching
Forks
0 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 - umangtank/BackOrder: Predicting Backorders using Machine Learning. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder-prediction ❗

Backorder is an order which can’t be fulfilled at the given time due to lack of supply or the product is currently out of stock or not in inventory but can guarantee delivery of the goods or service requested by a certain date in the future because the production of goods or replenishment of inventory is underway. Unlike in the situation of Out-of-stock where the delivery date of the goods can’t be promised , in the Backorder scenario the customers are allowed to shop for the products and order. Simply put Backorder can be thought of as an order with a delayed delivery date.


Backorders are unavoidable, but by anticipating which things will be backordered, planning can be streamlined at several levels, preventing unexpected strain on production, logistics, and transportation. ERP systems generate a lot of data (mainly structured) and also contain a lot of historical data; if this data can be properly utilized, a predictive model to forecast backorders and plan accordingly can be constructed. Based on past data from inventories, supply chain, and sales, classify the products as going into backorder (Yes or No).

Data Analysis
In the Train dataset we are provided with 23 columns(Features) of data.
  • Sku(Stock Keeping unit) : The product id — Unique for each row so can be ignored
  • National_inv : The present inventory level of the product
  • Lead_time : Transit time of the product
  • In_transit_qty : The amount of product in transit
  • Forecast_3_month , Forecast_6_month , Forecast_9_month : Forecast of the sales of the product for coming 3 , 6 and 9 months respectively
  • Sales_1_month , sales_3_month ,sales_6_month , sales_9_month : Actual sales of the product in last 1 , 3 ,6 and 9 months respectively
  • Min_bank : Minimum amount of stock recommended
  • Potential_issue : Any problem identified in the product/part
  • Pieces_past_due: Amount of parts of the product overdue if any
  • Perf_6_month_avg , perf_12_month_avg : Product performance over past 6 and 12 months respectively
  • Local_bo_qty : Amount of stock overdue
  • Deck_risk , oe_constraint, ppap_risk, stop_auto_buy, rev_stop : Different Flags (Yes or No) set for the product
  • Went_on_backorder : Target variable
Out of the 23 features given in the dataset 15 are numerical and 8(including the target variable) are categorical features.
User InterFace
  • Home Page
  • Predict Page
Approach
The main goal is to predict the whether a product comes in backorder or not based on different factors available in the dataset.
  • Data Exploration : Exploring dataset using pandas,numpy,matplotlib and seaborn.
  • Data visualization : Ploted graphs to get insights about dependend and independed variables.
  • Feature Engineering : Removed missing values and created new features as per insights.
  • Model Selection I : Tested all base models to check the base accuracy. Also ploted and calculate Performance Metrics to check whether a model is a good fit or not.
  • Model Selection II : Performed Hyperparameter tuning using RandomsearchCV.
  • Pickle File : Selected model as per best accuracy and created pickle file using pickle library.
  • Webpage & deployment : Created a webform that takes all the necessary inputs from user and shows output. After that I have deployed project on AWS .
Technologies Used
  • VS-Code Is Used For IDE.
  • For Visualization Of The Plots Matplotlib , Seaborn Are Used.
  • Heroku is Used For Model Deployment.
  • mongoDB Database Is Used To As Data Base.
  • Front End Deployment Is Done Using HTML , CSS.
  • Flask is for creating the application server and pages.
  • Git Hub Is Used As A Version Control System.
  • josn is for data validation processes.
  • os is used for creating and deleting folders.
  • csv is used for creating .csv format file.
  • numpy is for arrays computations and mathematical operations
  • pandas is for Manipulation and wrangling structured data
  • scikit-learn is used for machine learning tool kit
  • pickle is used for saving model
  • XgBoost is used for XgBoostClassifier Implementation.
  • Nearmiss Imbalance is used for handling Imbalance Data.
Run Locally
  • Clone the project
 git clone https://github.com/umangtank/BackOrder
  • Go to the project directory
cd BackOrder
  • Install dependencies
pip install -r requirements.txt
  • Run the app.py
 python app.py
Usage
In Development If You Want to contribute? Great!
To fix a bug or enhance an existing module, follow these steps:
  • Fork the repo
  • Create a new branch
 git checkout -b new-feature
  • Make the appropriate changes in the file
  • Commit your changes
 git commit -m "New feature added"
  • Push to the branch
 git push origin new-feature
  • Create a pull request
Help Me Improve
Hello Reader if you find any bug please consider raising issue I will address them asap.
About
Predicting Backorders using Machine Learning.
Topics
backordersdata-sciencemachine-learning
Resources
Readme
GPL-3.0 license
Activity
Stars
5 stars
Watchers
1 watching
Forks
0 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 - umangtank/BackOrder: Predicting Backorders using Machine Learning. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder-prediction ❗

Backorder is an order which can’t be fulfilled at the given time due to lack of supply or the product is currently out of stock or not in inventory but can guarantee delivery of the goods or service requested by a certain date in the future because the production of goods or replenishment of inventory is underway. Unlike in the situation of Out-of-stock where the delivery date of the goods can’t be promised , in the Backorder scenario the customers are allowed to shop for the products and order. Simply put Backorder can be thought of as an order with a delayed delivery date.


Backorders are unavoidable, but by anticipating which things will be backordered, planning can be streamlined at several levels, preventing unexpected strain on production, logistics, and transportation. ERP systems generate a lot of data (mainly structured) and also contain a lot of historical data; if this data can be properly utilized, a predictive model to forecast backorders and plan accordingly can be constructed. Based on past data from inventories, supply chain, and sales, classify the products as going into backorder (Yes or No).

Data Analysis
In the Train dataset we are provided with 23 columns(Features) of data.
  • Sku(Stock Keeping unit) : The product id — Unique for each row so can be ignored
  • National_inv : The present inventory level of the product
  • Lead_time : Transit time of the product
  • In_transit_qty : The amount of product in transit
  • Forecast_3_month , Forecast_6_month , Forecast_9_month : Forecast of the sales of the product for coming 3 , 6 and 9 months respectively
  • Sales_1_month , sales_3_month ,sales_6_month , sales_9_month : Actual sales of the product in last 1 , 3 ,6 and 9 months respectively
  • Min_bank : Minimum amount of stock recommended
  • Potential_issue : Any problem identified in the product/part
  • Pieces_past_due: Amount of parts of the product overdue if any
  • Perf_6_month_avg , perf_12_month_avg : Product performance over past 6 and 12 months respectively
  • Local_bo_qty : Amount of stock overdue
  • Deck_risk , oe_constraint, ppap_risk, stop_auto_buy, rev_stop : Different Flags (Yes or No) set for the product
  • Went_on_backorder : Target variable
Out of the 23 features given in the dataset 15 are numerical and 8(including the target variable) are categorical features.
User InterFace
  • Home Page
  • Predict Page
Approach
The main goal is to predict the whether a product comes in backorder or not based on different factors available in the dataset.
  • Data Exploration : Exploring dataset using pandas,numpy,matplotlib and seaborn.
  • Data visualization : Ploted graphs to get insights about dependend and independed variables.
  • Feature Engineering : Removed missing values and created new features as per insights.
  • Model Selection I : Tested all base models to check the base accuracy. Also ploted and calculate Performance Metrics to check whether a model is a good fit or not.
  • Model Selection II : Performed Hyperparameter tuning using RandomsearchCV.
  • Pickle File : Selected model as per best accuracy and created pickle file using pickle library.
  • Webpage & deployment : Created a webform that takes all the necessary inputs from user and shows output. After that I have deployed project on AWS .
Technologies Used
  • VS-Code Is Used For IDE.
  • For Visualization Of The Plots Matplotlib , Seaborn Are Used.
  • Heroku is Used For Model Deployment.
  • mongoDB Database Is Used To As Data Base.
  • Front End Deployment Is Done Using HTML , CSS.
  • Flask is for creating the application server and pages.
  • Git Hub Is Used As A Version Control System.
  • josn is for data validation processes.
  • os is used for creating and deleting folders.
  • csv is used for creating .csv format file.
  • numpy is for arrays computations and mathematical operations
  • pandas is for Manipulation and wrangling structured data
  • scikit-learn is used for machine learning tool kit
  • pickle is used for saving model
  • XgBoost is used for XgBoostClassifier Implementation.
  • Nearmiss Imbalance is used for handling Imbalance Data.
Run Locally
  • Clone the project
 git clone https://github.com/umangtank/BackOrder
  • Go to the project directory
cd BackOrder
  • Install dependencies
pip install -r requirements.txt
  • Run the app.py
 python app.py
Usage
In Development If You Want to contribute? Great!
To fix a bug or enhance an existing module, follow these steps:
  • Fork the repo
  • Create a new branch
 git checkout -b new-feature
  • Make the appropriate changes in the file
  • Commit your changes
 git commit -m "New feature added"
  • Push to the branch
 git push origin new-feature
  • Create a pull request
Help Me Improve
Hello Reader if you find any bug please consider raising issue I will address them asap.
About
Predicting Backorders using Machine Learning.
Topics
backordersdata-sciencemachine-learning
Resources
Readme
GPL-3.0 license
Activity
Stars
5 stars
Watchers
1 watching
Forks
0 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 - umangtank/BackOrder: Predicting Backorders using Machine Learning. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder-prediction ❗

Backorder is an order which can’t be fulfilled at the given time due to lack of supply or the product is currently out of stock or not in inventory but can guarantee delivery of the goods or service requested by a certain date in the future because the production of goods or replenishment of inventory is underway. Unlike in the situation of Out-of-stock where the delivery date of the goods can’t be promised , in the Backorder scenario the customers are allowed to shop for the products and order. Simply put Backorder can be thought of as an order with a delayed delivery date.


Backorders are unavoidable, but by anticipating which things will be backordered, planning can be streamlined at several levels, preventing unexpected strain on production, logistics, and transportation. ERP systems generate a lot of data (mainly structured) and also contain a lot of historical data; if this data can be properly utilized, a predictive model to forecast backorders and plan accordingly can be constructed. Based on past data from inventories, supply chain, and sales, classify the products as going into backorder (Yes or No).

Data Analysis
In the Train dataset we are provided with 23 columns(Features) of data.
  • Sku(Stock Keeping unit) : The product id — Unique for each row so can be ignored
  • National_inv : The present inventory level of the product
  • Lead_time : Transit time of the product
  • In_transit_qty : The amount of product in transit
  • Forecast_3_month , Forecast_6_month , Forecast_9_month : Forecast of the sales of the product for coming 3 , 6 and 9 months respectively
  • Sales_1_month , sales_3_month ,sales_6_month , sales_9_month : Actual sales of the product in last 1 , 3 ,6 and 9 months respectively
  • Min_bank : Minimum amount of stock recommended
  • Potential_issue : Any problem identified in the product/part
  • Pieces_past_due: Amount of parts of the product overdue if any
  • Perf_6_month_avg , perf_12_month_avg : Product performance over past 6 and 12 months respectively
  • Local_bo_qty : Amount of stock overdue
  • Deck_risk , oe_constraint, ppap_risk, stop_auto_buy, rev_stop : Different Flags (Yes or No) set for the product
  • Went_on_backorder : Target variable
Out of the 23 features given in the dataset 15 are numerical and 8(including the target variable) are categorical features.
User InterFace
  • Home Page
  • Predict Page
Approach
The main goal is to predict the whether a product comes in backorder or not based on different factors available in the dataset.
  • Data Exploration : Exploring dataset using pandas,numpy,matplotlib and seaborn.
  • Data visualization : Ploted graphs to get insights about dependend and independed variables.
  • Feature Engineering : Removed missing values and created new features as per insights.
  • Model Selection I : Tested all base models to check the base accuracy. Also ploted and calculate Performance Metrics to check whether a model is a good fit or not.
  • Model Selection II : Performed Hyperparameter tuning using RandomsearchCV.
  • Pickle File : Selected model as per best accuracy and created pickle file using pickle library.
  • Webpage & deployment : Created a webform that takes all the necessary inputs from user and shows output. After that I have deployed project on AWS .
Technologies Used
  • VS-Code Is Used For IDE.
  • For Visualization Of The Plots Matplotlib , Seaborn Are Used.
  • Heroku is Used For Model Deployment.
  • mongoDB Database Is Used To As Data Base.
  • Front End Deployment Is Done Using HTML , CSS.
  • Flask is for creating the application server and pages.
  • Git Hub Is Used As A Version Control System.
  • josn is for data validation processes.
  • os is used for creating and deleting folders.
  • csv is used for creating .csv format file.
  • numpy is for arrays computations and mathematical operations
  • pandas is for Manipulation and wrangling structured data
  • scikit-learn is used for machine learning tool kit
  • pickle is used for saving model
  • XgBoost is used for XgBoostClassifier Implementation.
  • Nearmiss Imbalance is used for handling Imbalance Data.
Run Locally
  • Clone the project
 git clone https://github.com/umangtank/BackOrder
  • Go to the project directory
cd BackOrder
  • Install dependencies
pip install -r requirements.txt
  • Run the app.py
 python app.py
Usage
In Development If You Want to contribute? Great!
To fix a bug or enhance an existing module, follow these steps:
  • Fork the repo
  • Create a new branch
 git checkout -b new-feature
  • Make the appropriate changes in the file
  • Commit your changes
 git commit -m "New feature added"
  • Push to the branch
 git push origin new-feature
  • Create a pull request
Help Me Improve
Hello Reader if you find any bug please consider raising issue I will address them asap.
About
Predicting Backorders using Machine Learning.
Topics
backordersdata-sciencemachine-learning
Resources
Readme
GPL-3.0 license
Activity
Stars
5 stars
Watchers
1 watching
Forks
0 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 - umangtank/BackOrder: Predicting Backorders using Machine Learning. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder-prediction ❗

Backorder is an order which can’t be fulfilled at the given time due to lack of supply or the product is currently out of stock or not in inventory but can guarantee delivery of the goods or service requested by a certain date in the future because the production of goods or replenishment of inventory is underway. Unlike in the situation of Out-of-stock where the delivery date of the goods can’t be promised , in the Backorder scenario the customers are allowed to shop for the products and order. Simply put Backorder can be thought of as an order with a delayed delivery date.


Backorders are unavoidable, but by anticipating which things will be backordered, planning can be streamlined at several levels, preventing unexpected strain on production, logistics, and transportation. ERP systems generate a lot of data (mainly structured) and also contain a lot of historical data; if this data can be properly utilized, a predictive model to forecast backorders and plan accordingly can be constructed. Based on past data from inventories, supply chain, and sales, classify the products as going into backorder (Yes or No).

Data Analysis
In the Train dataset we are provided with 23 columns(Features) of data.
  • Sku(Stock Keeping unit) : The product id — Unique for each row so can be ignored
  • National_inv : The present inventory level of the product
  • Lead_time : Transit time of the product
  • In_transit_qty : The amount of product in transit
  • Forecast_3_month , Forecast_6_month , Forecast_9_month : Forecast of the sales of the product for coming 3 , 6 and 9 months respectively
  • Sales_1_month , sales_3_month ,sales_6_month , sales_9_month : Actual sales of the product in last 1 , 3 ,6 and 9 months respectively
  • Min_bank : Minimum amount of stock recommended
  • Potential_issue : Any problem identified in the product/part
  • Pieces_past_due: Amount of parts of the product overdue if any
  • Perf_6_month_avg , perf_12_month_avg : Product performance over past 6 and 12 months respectively
  • Local_bo_qty : Amount of stock overdue
  • Deck_risk , oe_constraint, ppap_risk, stop_auto_buy, rev_stop : Different Flags (Yes or No) set for the product
  • Went_on_backorder : Target variable
Out of the 23 features given in the dataset 15 are numerical and 8(including the target variable) are categorical features.
User InterFace
  • Home Page
  • Predict Page
Approach
The main goal is to predict the whether a product comes in backorder or not based on different factors available in the dataset.
  • Data Exploration : Exploring dataset using pandas,numpy,matplotlib and seaborn.
  • Data visualization : Ploted graphs to get insights about dependend and independed variables.
  • Feature Engineering : Removed missing values and created new features as per insights.
  • Model Selection I : Tested all base models to check the base accuracy. Also ploted and calculate Performance Metrics to check whether a model is a good fit or not.
  • Model Selection II : Performed Hyperparameter tuning using RandomsearchCV.
  • Pickle File : Selected model as per best accuracy and created pickle file using pickle library.
  • Webpage & deployment : Created a webform that takes all the necessary inputs from user and shows output. After that I have deployed project on AWS .
Technologies Used
  • VS-Code Is Used For IDE.
  • For Visualization Of The Plots Matplotlib , Seaborn Are Used.
  • Heroku is Used For Model Deployment.
  • mongoDB Database Is Used To As Data Base.
  • Front End Deployment Is Done Using HTML , CSS.
  • Flask is for creating the application server and pages.
  • Git Hub Is Used As A Version Control System.
  • josn is for data validation processes.
  • os is used for creating and deleting folders.
  • csv is used for creating .csv format file.
  • numpy is for arrays computations and mathematical operations
  • pandas is for Manipulation and wrangling structured data
  • scikit-learn is used for machine learning tool kit
  • pickle is used for saving model
  • XgBoost is used for XgBoostClassifier Implementation.
  • Nearmiss Imbalance is used for handling Imbalance Data.
Run Locally
  • Clone the project
 git clone https://github.com/umangtank/BackOrder
  • Go to the project directory
cd BackOrder
  • Install dependencies
pip install -r requirements.txt
  • Run the app.py
 python app.py
Usage
In Development If You Want to contribute? Great!
To fix a bug or enhance an existing module, follow these steps:
  • Fork the repo
  • Create a new branch
 git checkout -b new-feature
  • Make the appropriate changes in the file
  • Commit your changes
 git commit -m "New feature added"
  • Push to the branch
 git push origin new-feature
  • Create a pull request
Help Me Improve
Hello Reader if you find any bug please consider raising issue I will address them asap.
About
Predicting Backorders using Machine Learning.
Topics
backordersdata-sciencemachine-learning
Resources
Readme
GPL-3.0 license
Activity
Stars
5 stars
Watchers
1 watching
Forks
0 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 - umangtank/BackOrder: Predicting Backorders using Machine Learning. · GitHub
Skip to content
BranchesTags
Repository files navigation
Backorder-prediction ❗

Backorder is an order which can’t be fulfilled at the given time due to lack of supply or the product is currently out of stock or not in inventory but can guarantee delivery of the goods or service requested by a certain date in the future because the production of goods or replenishment of inventory is underway. Unlike in the situation of Out-of-stock where the delivery date of the goods can’t be promised , in the Backorder scenario the customers are allowed to shop for the products and order. Simply put Backorder can be thought of as an order with a delayed delivery date.


Backorders are unavoidable, but by anticipating which things will be backordered, planning can be streamlined at several levels, preventing unexpected strain on production, logistics, and transportation. ERP systems generate a lot of data (mainly structured) and also contain a lot of historical data; if this data can be properly utilized, a predictive model to forecast backorders and plan accordingly can be constructed. Based on past data from inventories, supply chain, and sales, classify the products as going into backorder (Yes or No).

Data Analysis
In the Train dataset we are provided with 23 columns(Features) of data.
  • Sku(Stock Keeping unit) : The product id — Unique for each row so can be ignored
  • National_inv : The present inventory level of the product
  • Lead_time : Transit time of the product
  • In_transit_qty : The amount of product in transit
  • Forecast_3_month , Forecast_6_month , Forecast_9_month : Forecast of the sales of the product for coming 3 , 6 and 9 months respectively
  • Sales_1_month , sales_3_month ,sales_6_month , sales_9_month : Actual sales of the product in last 1 , 3 ,6 and 9 months respectively
  • Min_bank : Minimum amount of stock recommended
  • Potential_issue : Any problem identified in the product/part
  • Pieces_past_due: Amount of parts of the product overdue if any
  • Perf_6_month_avg , perf_12_month_avg : Product performance over past 6 and 12 months respectively
  • Local_bo_qty : Amount of stock overdue
  • Deck_risk , oe_constraint, ppap_risk, stop_auto_buy, rev_stop : Different Flags (Yes or No) set for the product
  • Went_on_backorder : Target variable
Out of the 23 features given in the dataset 15 are numerical and 8(including the target variable) are categorical features.
User InterFace
  • Home Page
  • Predict Page
Approach
The main goal is to predict the whether a product comes in backorder or not based on different factors available in the dataset.
  • Data Exploration : Exploring dataset using pandas,numpy,matplotlib and seaborn.
  • Data visualization : Ploted graphs to get insights about dependend and independed variables.
  • Feature Engineering : Removed missing values and created new features as per insights.
  • Model Selection I : Tested all base models to check the base accuracy. Also ploted and calculate Performance Metrics to check whether a model is a good fit or not.
  • Model Selection II : Performed Hyperparameter tuning using RandomsearchCV.
  • Pickle File : Selected model as per best accuracy and created pickle file using pickle library.
  • Webpage & deployment : Created a webform that takes all the necessary inputs from user and shows output. After that I have deployed project on AWS .
Technologies Used
  • VS-Code Is Used For IDE.
  • For Visualization Of The Plots Matplotlib , Seaborn Are Used.
  • Heroku is Used For Model Deployment.
  • mongoDB Database Is Used To As Data Base.
  • Front End Deployment Is Done Using HTML , CSS.
  • Flask is for creating the application server and pages.
  • Git Hub Is Used As A Version Control System.
  • josn is for data validation processes.
  • os is used for creating and deleting folders.
  • csv is used for creating .csv format file.
  • numpy is for arrays computations and mathematical operations
  • pandas is for Manipulation and wrangling structured data
  • scikit-learn is used for machine learning tool kit
  • pickle is used for saving model
  • XgBoost is used for XgBoostClassifier Implementation.
  • Nearmiss Imbalance is used for handling Imbalance Data.
Run Locally
  • Clone the project
 git clone https://github.com/umangtank/BackOrder
  • Go to the project directory
cd BackOrder
  • Install dependencies
pip install -r requirements.txt
  • Run the app.py
 python app.py
Usage
In Development If You Want to contribute? Great!
To fix a bug or enhance an existing module, follow these steps:
  • Fork the repo
  • Create a new branch
 git checkout -b new-feature
  • Make the appropriate changes in the file
  • Commit your changes
 git commit -m "New feature added"
  • Push to the branch
 git push origin new-feature
  • Create a pull request
Help Me Improve
Hello Reader if you find any bug please consider raising issue I will address them asap.
About
Predicting Backorders using Machine Learning.
Topics
backordersdata-sciencemachine-learning
Resources
Readme
GPL-3.0 license
Activity
Stars
5 stars
Watchers
1 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages