Mathematical modeling of CCR, BCC, and super-efficiency models using python’s pulp library

Article directory

  • Mathematical modeling of CCR, BCC, and super-efficiency models using python’s pulp library
  • 1. CCR, BCC, and super-efficiency model formulas?
    • 1. Input-oriented CCR dual formula
    • 2. BCC model formula
    • 3. Super efficiency model formula
  • 2. Mathematical Model Construction
    • 1. Data example
      • 1.1 How to use the pulp package
      • 1.2 After learning basic modeling, apply the CCR formula given in the book
    • 2. Object-oriented, write class functions
    • 3. Test
  • Summarize

Mathematical modeling of CCR, BCC, and super-efficiency models using python’s pulp library

The bibliography of this article is
“Data Envelopment Analysis Method and MaxDEA Software”

1. CCR, BCC, super-efficiency model formulas?

1. Input-oriented CCR dual formula

Example: pandas is a NumPy-based tool created to solve data analysis tasks .

2. BCC model formula

3. Super efficiency model formula

2. Mathematical model construction

1. Data example

import pandas as pd
data = pd.DataFrame([[4,3,1],[7,3,1],[8,1,1],[4,2,1],[2,4,1],[10, 1,1],[12,1,1],[10,1.5,1]],columns=['x1','x2','y'],index=['A','B',' C','D','E','F','G','H'])
data
>>>
    x1 x2 y
A 4 3.0 1
B 7 3.0 1
C 8 1.0 1
D 4 2.0 1
E 2 4.0 1
F 10 1.0 1
G 12 1.0 1
H 10 1.5 1

1.1 How to use pulp package

d = np.array([2,3,1])
da = np.array([1,2,4])
da1 = np.array([[1,3],[4,2],[2,0]])
r = np.array([8,6])
m = pulp.LpProblem(sense=pulp.LpMinimize)
x1 = pulp.LpVariable.dict("x",range(3),lowBound=0)
x = list(x1. values())
m + = pulp.lpSum([d[i0] * x[i0] for i0 in range(3)])
for i in range(2):
    m + = pulp.lpSum([x[i0] * da1[i0][i] for i0 in range(3)]) >= r[i]
m + = ( pulp.lpDot(da , x) == 101 )
m. solve()
pulp. value(m. objective)
>>>
28.75
>>>
# The above may be too complicated, you can refer to a simple example
z = [2,3,1]
a = [[1,4,2],[3,2,0]]
b = [8,6]
c = [1,2,4]
d = 101
m1 = pulp.LpProblem(sense=pulp.LpMinimize) #define function
x = [pulp.LpVariable(f"x_{<!-- -->i}",lowBound=0) for i in range(3)] #Set variable
m1 + = pulp.lpDot(z, x) # "m1 + =" is a fixed symbol, if there is no constraint behind it, it means that this statement is the objective function
m1 + = pulp.lpDot(c,x) == d # constraints
for i in range(len(a)): # constraints
    m1 + = (pulp.lpDot(a[i], x) >= b[i])
m1. solve()
pulp.value(m1.objective) # The obtained value
>>>
28.75
>>>
m1 #View the entire formula of the definition function
>>>
NoName:
MINIMIZE
2*x_0 + 3*x_1 + 1*x_2 + 0
SUBJECT TO
_C1: x_0 + 2 x_1 + 4 x_2 = 101

_C2: x_0 + 4 x_1 + 2 x_2 >= 8

_C3: 3 x_0 + 2 x_1 >= 6

VARIABLES
x_0 Continuous
x_1 Continuous
x_2 Continuous
>>>

1.2 After learning basic modeling, apply the CCR formula given in the book

# non-super-efficient CCR model
import pulp as lp
DMUs = data.index.values
d_var = data.columns.values
# variables
var = lp.LpVariable.dict("DMU",data.index.values,lowBound=0)
thita = lp. LpVariable('thita')

for DMU in DMUs:
    # objective function
    pr = lp.LpProblem('CCR',lp.LpMinimize)
    pr + = thita
    # Restrictions
    pr + = lp.lpSum(data.to_dict()['x1'][i] * var[i] for i in DMUs) <= thita * data.to_dict()['x1'][DMU]
    pr + = lp.lpSum(data.to_dict()['x2'][i] * var[i] for i in DMUs) <= thita * data.to_dict()['x2'][DMUs]
    pr + = lp.lpSum(data.to_dict()['y'][i] * var[i] for i in DMUs) >= data.to_dict()['y'][DMU]
    #pr + = lp.lpSum(var) == 1
    result = pr.solve()
    print(DMU,":",lp. value(thita))
>>>
A : 0.85714286
B : 0.63157895
C : 1.0
D : 1.0
E : 1.0
F : 1.0
G : 1.0
H : 0.75
#Super efficient CCR model
import pulp as lp
DMUs = data.index.values
d_var = data.columns.values
var = lp.LpVariable.dict("DMU",data.index.values,lowBound=0)
thita = lp. LpVariable('thita')
for DMU in DMUs:
    pr = lp.LpProblem('CCR',lp.LpMinimize)
    pr + = thita
    pr + = lp.lpSum(data.to_dict()['x1'][i] * var[i] for i in DMUs if i != DMU) <= thita * data.to_dict()['x1'][ DMU]
    pr + = lp.lpSum(data.to_dict()['x2'][i] * var[i] for i in DMUs if i != DMU) <= thita * data.to_dict()['x2'][ DMU]
    pr + = lp.lpSum(data.to_dict()['y'][i] * var[i] for i in DMUs if i != DMU) >= data.to_dict()['y'][DMU]
    # pr + = lp.lpSum(var) == 1
    result = pr.solve()
    print(DMU,":",lp. value(thita))
>>>
A : 0.85714286
B : 0.63157895
C : 1.1428571
D : 1.25
E : 2.0
F : 1.0
G : 1.0
H : 0.75

2. Object-oriented, write class functions

The code is as follows (example):

#CCRModel
import pandas as pd
import numpy as np
import pulp as lp
class DEA_CCR:
    def __init__(self, data, inputs_numbers, outputs_numbers, returns="CRS"):
        """
        data (data is in the form of pd.DataFrame);
        inputs_numbers (input input number);
        outputs_numbers (input output number);
        returns (type "CRS" or "VRS")

        """
        self.data = data
        self.inputs_numbers = inputs_numbers
        self.outputs_numbers = outputs_numbers
        self. returns = returns
        self.DMUs = data.index.values
        self.d_var = data.columns.values

    def _CCR(self):

        self.var = lp.LpVariable.dict("DMU",self.data.index.values,lowBound=0)
        thita = lp. LpVariable('thita')

        dums_dict = {<!-- -->}
        for DMU in self. DMUs:
            pr = lp.LpProblem('CCR',lp.LpMinimize)
            pr + = thita
            if self. returns == "VRS":
                pr + = lp.lpSum(self.var) == 1
            for j0 in self.d_var[0:self.inputs_numbers]:
                pr + = lp.lpSum(self.data.to_dict()[j0][i] * self.var[i] for i in self.DMUs) <= thita * self.data.to_dict()[j0][DMUs ]
            for r0 in self.d_var[self.inputs_numbers:self.inputs_numbers + self.outputs_numbers]:
                pr + = lp.lpSum(self.data.to_dict()[r0][i] * self.var[i] for i in self.DMUs) >= self.data.to_dict()[r0][DMUs]
            pr. solve()
            dums_dict[DMU] = lp.value(pr.objective)
            dums_dict_data = pd.DataFrame.from_dict(dums_dict, orient='index')
        return dums_dict_data


    def _CCR_super(self):
      
        self.var = lp.LpVariable.dict("DMU",self.data.index.values,lowBound=0)
        thita = lp. LpVariable('thita')
        
        dums_dict = {<!-- -->}
        for DMU in self. DMUs:
            pr = lp.LpProblem('CCR',lp.LpMinimize)
            pr + = thita
            if self. returns == "VRS":
                pr + = lp.lpSum([self.var[i] for i in DMUs if i!= DMU]) == 1 #Super-efficient VRS is slightly different from non-super-efficient
            for j0 in self.d_var[0:self.inputs_numbers]:
                pr + = lp.lpSum([self.data.to_dict()[j0][i] * self.var[i] for i in self.DMUs if i != DMU]) <= thita * self.data.to_dict ()[j0][DMU]
            for r0 in self.d_var[self.inputs_numbers:self.inputs_numbers + self.outputs_numbers]:
                pr + = lp.lpSum([self.data.to_dict()[r0][i] * self.var[i] for i in self.DMUs if i != DMU]) >= self.data.to_dict() [r0][DMU]
            result = pr.solve()
            dums_dict[DMU] = lp.value(pr.objective)
            dums_dict_data = pd.DataFrame.from_dict(dums_dict, orient='index')
        return dums_dict_data

3. Test

The code is as follows (example):

C_data = DEA_CCR(data,2,2,returns = "VRS")._CCR()
C_data
>>>
A 0.857143
B 0.631579
C 1.000000
D 1.000000
E 1.000000
F 1.000000
G 1.000000
H 0.750000
C_data = DEA_CCR(data,2,2,returns = "VRS")._CCR_super()
C_data
>>>
A 0.857143
B 0.631579
C 1.142857
D 1.250000
E 2.000000
F 1.000000
G 1.000000
H 0.750000

Summary

  1. Model and test the basic formula first
  2. Then put it into the class package