May 5, 2024
Latest: Linear Programming using Pyomo
MATHEMATICS OPTIMIZATION TECHNIQUES PYTHON
Solving Linear Programming using Python
PuLP
January 20, 2022 Avinash Navlani
Learn how to use Python PuLP to solve linear programming problems.
As a Senior operation manager, your job is to optimize scarce resources, improve productivity,
reduce cost, and maximize profit. For example, you want to maximize the profit of the
manufacturing unit with constraints like labor working hours, machine capacity, and available raw
material. Another example is that of a marketing manager who wants to allocate the optimum
budget among alternative advertising media channels such as radio, television, newspapers, and
magazines. Such problems can be considered optimization problems.
Optimization problems can be represented as a mathematical function that captures the tradeoff
between the decisions that need to be made. The feasible solutions to such problems depend upon
constraints specified in mathematical form.
Linear programming is the core of any optimization problem. It is used to solve a wide variety of
planning and supply chain optimization. Linear programming was introduced by George Dantzig in
1947. It uses linear algebra for determining the optimal allocation of scarce resources.
Linear Programming
In this tutorial, we are going to cover the following topics:
Contents [ hide ]
1 Linear Programming
2 Methods for Solving Linear Programming Problems
3 Components of Linear Programming
4 Modeling Linear Programming Using Python PuLP
4.1 Understand the problem
4.2 Initialize Model
4.3 Define Decision Variable
4.4 Define Objective Function
4.5 Define the Constraints
4.6 Solve Model
5 Summary
Linear Programming
LP models are based on linear relationships. It assumes that the objective and the constraint
function in all LPs must be linear. This mathematical technique is used to solve the constrained
optimization problem. There are 4 basic assumptions of LP models:
Additivity Assumption: The terms of objective function and constraints must be
additive. e.g. total consumption must equal to sum of the profits from each
decision variable and total contributions to the problem objective, resulting in
carrying out each activity independently.
Proportionality Assumption: Each decision variable has a linear impact on the
linear objective function and in each constraint. The consumptions and
contributions for each activity are proportional to the actual activity level.
Divisibility Assumption: Decision variables may accept the non-integer value. Each
variable is allowed to have fractional values (continuous variables).
Certainty Assumption: Each coefficient of the objective vector and constraint
matrix is known with certainty (not a random variable)
(https://link.springer.com/book/10.1007/978-3-319-68837-4). Model parameters
are known and constrained. Relevant constraints have been identified and
represented in the model.
Methods for Solving Linear Programming
Problems
These are the following methods used to solve the Linear Programming Problem:
Graphical Method
Simplex Method
Karmakar’s Method
Graphical is limited to the two-variable problem while Simplex and Karmakar’s method can be used
for more than two variables.
Components of Linear Programming
Decision Variables: What you can control.
Objective Function: math expressions that use variables to express goals.
Constraints: math expressions that describe the limit of a solution.
Modeling Linear Programming Using
Python PuLP
There are various excellent optimization Python packages are available such as SciPy, PuLP, Gurobi,
and CPLEX. In this article, we will focus on the PuLP Python library. PuLP is a general-purpose and
open-source Linear Programming modeling package in Python.
Install pulp package:
Python
1 !pip install pulp
PuLP modeling process has the following steps for solving LP problems:
Initialize Model
Define Decision Variable
Define Objective Function
Define the Constraints
Solve Model
Understand the problem
This problem is taken from Introduction to Management Science By Stevenson and Ozgur.
A furniture company produces a variety of products. One department specializes in wood tables, chairs,
and bookcases. These are made using three resources labor, wood, and machine time. The department
has 60 hours of labor available each day, 16 hours of machine time, and 400 board feet of wood. A
consultant has developed a linear programming model for the department.
x1= quantity of tables
x2= quantity of chairs
x3= quantity of bookcases
Objective Function: Profit = 40*x1+30*x2+45*x3
Constraints:
labor: 2*x1 + 1*x2 + 2.5*x3 <= 60 Hours
Machine: 0.8*x1 + 0.6*x2 + 1.0*x3 <= 16 Hours
Wood: 30*x1 + 20*x2 + 30*x3 <= 400 board-feet
Tables: x1>=10 board-feet
x1, x2, x3 >= 0
Initialize Model
In this step, we will import all the classes and functions of pulp module and create a Maxzimization
LP problem using LpProblem class.
Python
1 # Import all classes of PuLP module
2 from pulp import *
3
4 # Create the problem variable to contain the problem data
5 model = LpProblem("FurnitureProblem", LpMaximize)
Define Decision Variable
In this step, we will define the decision variables. In our problem, we have three variables wood
tables, chairs, and bookcases. Let’s create them using LpVariable class. LpVariable will take the
following four values:
First, the arbitrary name of what this variable represents.
Second is the lower bound on this variable.
Third is the upper bound.
Fourth is essentially the type of data (discrete or continuous). The options for the
fourth parameter are LpContinuous or LpInteger.
Python
1 # Create 3 variables tables, chairs, and bookcases
2
3 x1 = LpVariable("tables", 0, None, LpInteger)
4 x2 = LpVariable("chairs", 0, None, LpInteger)
5 x3 = LpVariable("bookcases", 0, None, LpInteger)
Define Objective Function
In this step, we will define the maximum objective function by adding it to the LpProblem object.
Python
1 # Create maximize objective function
2 model += 40 * x1 + 30 * x2 + 45 * x3
Define the Constraints
In this step, we will add the 4 constraints defined in the problem by adding them to the
LpProblem object.
Python
1 # Create three constraints
2 model += 2 * x1 + 1 * x2 + 2.5 * x3 <= 60, "Labour"
3 model += 0.8 * x1 + 0.6 * x2 + 1.0 * x3 <= 16, "Machine"
4 model += 30 * x1 + 20 * x2 + 30 * x3 <= 400, "wood"
5 model += x1 >= 10, "tables"
Solve Model
In this step, we will solve the LP problem by calling solve() method. We can print the final value by
using the following for loop.
Python
1 # The problem is solved using PuLP's choice of Solver
2 model.solve()
3
4 # Each of the variables is printed with it's resolved optimum value
5 for v in model.variables():
6 print(v.name, "=", v.varValue)
Output:
bookcases = 0.0
chairs = 5.0
tables = 10.0
Summary
Congratulations, you have made it to the end of this tutorial!
In this article, we have learned Linear Programming, its assumptions, components, and
implementation in the Python PuLp library. We have solved the Linear programming problem using
PuLP. Of course, this is just the beginning, and there is a lot more that we can do using PuLP in
Optimization and Supply Chain. In upcoming articles, we will write more on different optimization
problems and their solutions using Python. You can revise the basics of mathematical concepts in
this article.
Spotify Song Recommender System in Python
Solving Staff Scheduling Problem using Linear Programming
You May Also Like
Sensitivity Analysis in Python
March 24, 2022
Grid Search in scikit-learn
November 7, 2020
Measures of Central Tendency
January 23, 2021
Latest Posts
MapReduce Algorithm
Linear Programming using Pyomo
Networking and Professional Development for Machine Learning Careers in the USA
Predicting Employee Churn in Python
Airflow Operators
MLOps Tutorial
Python Decorators
Python Generators
Python Iterators Examples
Big Data Interview Questions and Answers
About Us
We love Data Science and we are here to provide you Knowledge on Machine Learning, Text Analytics,
NLP, Statistics, Python, and Big Data. We focus on simple, elegant, and easy to learn tutorials.
Resources
AWS
Big Data
Business Analytics
Data Engineering
Deep Learning
Essentials Skills
Interview
Julia
Machine Learning
Mathematics
MLOps
NLP
Optimization Techniques
Python
pandas
Recommender System
Statistics
Text Analytics
Archives
April 2024
September 2023
July 2023
March 2023
February 2023
January 2023
November 2022
June 2022
May 2022
April 2022
March 2022
February 2022
January 2022
December 2021
September 2021
July 2021
June 2021
May 2021
April 2021
March 2021
February 2021
January 2021
December 2020
November 2020
October 2020
September 2020
Data Science Deals
DataCamp
UpGrad
Edureka Data Science
Dataquest
Privacy Policy
Copyright © 2024 Machine Learning Geek. All rights reserved.
Theme: ColorMag by ThemeGrill. Powered by WordPress.
