预算分配Budget Allocation：Morphl-AI的营销科学解决方案（一）

f(Cost) = f(Cost(t) | Cost(t-1), Revenue(t-1), ... Cost(t0), Revenue(t0)) = Revenue function

import pandas as pd

'''
模型一：直接算个总的ROI
Directly modeling f(Cost) = Revenue
'''
class StatisticalModel:
    def __init__(self):
        # This model has just a single parameter, computed as the count between targets and inputs
        self.param = np.nan
        
    def fit(self, x, t):
        assert self.param != self.param
        self.param = t.sum() / x.sum()  # 核心,非常简单的算一个ROI，作为系数进行计算
    
    def predict(self, x):
        assert self.param == self.param
        return x * self.param
    
def errorL1(y, t):
    return np.abs(y - t).mean()

def plot(model, valData, xKey, tKey):
    validCampaigns = list(valData.keys())
    ax = plt.subplots(len(validCampaigns), figsize=(5, 30))[1]
    for i, k in enumerate(validCampaigns):
        x = valData[k][xKey]
        t = valData[k][tKey]
        y = model[k].predict(x)
        ax[i].scatter(x, y, label="%s Predicted" % (tKey))
        ax[i].scatter(x, t)
        ax[i].set_title(k)
        ax[i].legend()

# 数据读入

conversion_data = pd.read_csv('Datasets/conversion_data.csv')
# marketing_spend_data = pd.read_csv('Datasets/marketing_spend_data.csv')


model_cost_revenue = {}
predictions_cost_revenue = {}
errors_cost_revenue = {}
displayDf = pd.DataFrame()
res_cost_revenue = []

campaigns = set(conversion_data['xyz_campaign_id'])
# from sklearn.model_selection import train_test_split
# X_train,X_test,y_train,y_test = train_test_split(iris.data,iris.target,test_size=0.3,random_state=0)
trainData = {}
valData = {}
for k in campaigns:
    data = conversion_data[conversion_data['xyz_campaign_id'] == k]
    num = int(len(data)*0.8)
    trainData[k] = data[:num]
    valData[k] = data[num:]

# Cost_col = 'Cost'
# Revenue_col = 'Revenue'
Cost_col = 'Spent'  # 投入
Revenue_col = 'Total_Conversion' # 产出

for k in campaigns:
    model_cost_revenue[k] = StatisticalModel()
    model_cost_revenue[k].fit(trainData[k][Cost_col], trainData[k][Revenue_col])
    predictions_cost_revenue[k] = model_cost_revenue[k].predict(valData[k][Cost_col])
    errors_cost_revenue[k] = errorL1(predictions_cost_revenue[k], valData[k][Revenue_col])
    res_cost_revenue.append([k, trainData[k][Cost_col].sum(), trainData[k][Revenue_col].sum(), \
                model_cost_revenue[k].param, errors_cost_revenue[k]])


displayDf = pd.DataFrame(res_cost_revenue, columns=["Campaign", Cost_col, Revenue_col, "Fit", "Error (L1)"])
display(displayDf)
print("Mean error:", displayDf["Error (L1)"].mean())

plot(model_cost_revenue, valData, Cost_col, Revenue_col)

Cost x Revenue ~= Cost x Sessions + Sessions x Revenue

曝光 = a1 * cost
收入 = a2 * 曝光

# 随机设定一个session
session_col = 'Impressions' # 曝光
Cost_col = 'Spent'  # 投入
Revenue_col = 'Total_Conversion' # 产出

# 第一步：曝光 = a1 * cost
model_cost_sessions = {}
predictions_cost_sessions = {}
errors_cost_sessions = {}
displayDf = pd.DataFrame()
res_cost_sessions = []
for k in campaigns:
    model_cost_sessions[k] = StatisticalModel()
    model_cost_sessions[k].fit(trainData[k][Cost_col], trainData[k][session_col])
    predictions_cost_sessions[k] = model_cost_sessions[k].predict(valData[k][Cost_col])
    errors_cost_sessions[k] = errorL1(predictions_cost_sessions[k], valData[k][session_col])
    res_cost_sessions.append([k, trainData[k][Cost_col].sum(), trainData[k][session_col].sum(), \
                model_cost_sessions[k].param, errors_cost_sessions[k]])

displayDf = pd.DataFrame(res_cost_sessions, columns=["Campaign", Cost_col, session_col, "Fit", "Error (L1)"])
display(displayDf)
print("Mean error:", displayDf["Error (L1)"].mean())

plot(model_cost_sessions, valData, Cost_col, session_col)

# 第二步：收入 = a2 * 曝光
model_sessions_revenue = {}
predictions_sessions_revenue = {}
errors_sessions_revenue = {}
displayDf = pd.DataFrame()
res_sessions_revenue = []
for k in campaigns:
    model_sessions_revenue[k] = StatisticalModel()
    model_sessions_revenue[k].fit(trainData[k][session_col], trainData[k][Revenue_col])
    predictions_sessions_revenue[k] = model_sessions_revenue[k].predict(valData[k][session_col])
    errors_sessions_revenue[k] = errorL1(predictions_sessions_revenue[k], valData[k][Revenue_col])
    res_sessions_revenue.append([k, trainData[k][session_col].sum(), trainData[k][Revenue_col].sum(), \
                model_sessions_revenue[k].param, errors_sessions_revenue[k]])

displayDf = pd.DataFrame(res_sessions_revenue, columns=["Campaign", session_col, Revenue_col, "Fit", "Error (L1)"])
display(displayDf)
print("Mean error:", displayDf["Error (L1)"].mean())

plot(model_sessions_revenue, valData, session_col, Revenue_col)

# 第三步：合并
displayDf = pd.DataFrame()
errors_cost_revenue = {}
res_cost_revenue_combined = []

class TwoModel(object):
    def __init__(self, modelA, modelB):
        self.modelA = modelA
        self.modelB = modelB
    
    def predict(self, x):
        return self.modelA.predict(self.modelB.predict(x))
models_cost_revenue = {k : TwoModel(model_cost_sessions[k], model_sessions_revenue[k]) for k in valData}

for k in campaigns:
    predictions_cost_revenue[k] = models_cost_revenue[k].predict(valData[k][Cost_col])
    errors_cost_revenue[k] = errorL1(predictions_cost_revenue[k], valData[k][Revenue_col])
    res_cost_revenue_combined.append([k, errors_cost_revenue[k]])

displayDf = pd.DataFrame(res_cost_revenue_combined, columns=["Campaign", "Error (L1)"])
display(displayDf)
print("Mean error:", displayDf["Error (L1)"].mean())


plot(models_cost_revenue, valData, Cost_col, Revenue_col)