AdStock & Saturation Transformations Practice

1
!pip install pyomo

1
!apt-get install -y -qq glpk-utils

1
import pandas as pd
2
import numpy as np
3

4
from google.colab import drive
5
drive.mount('/content/drive', force_remount=True)

1
dt_simulated_weekly = pd.read_csv('/content/drive/My Drive/Colab Notebooks/dt_simulated_weekly.csv')
2
dt_simulated_weekly

1
dt_simulated_weekly.isnull().sum()

1
dt_simulated_weekly.describe()

1
import matplotlib.pyplot as plt
2

3
dt_simulated_weekly['DATE'] = pd.to_datetime(dt_simulated_weekly['DATE'])
4
dt_simulated_weekly = dt_simulated_weekly.set_index('DATE')
5

6
plt.figure(figsize=(12, 6))
7
plt.plot(dt_simulated_weekly.index, dt_simulated_weekly['revenue'], marker='o')
8
plt.title("Weekly Time Series")
9
plt.xlabel("Date")
10
plt.ylabel("revenue")
11
plt.grid(True)
12
plt.show()

1
import random
2

3
hyperparameters = {
4
    'facebook_S_alpha': 1.115,
5
    'facebook_S_gamma': 2145.66,
6
    'facebook_S_theta': 0.216,
7
    'print_S_alpha': 2.735,
8
    'print_S_gamma': 3728.63,
9
    'print_S_theta': 0.130,
10
    'tv_S_alpha': 2.317,
11
    'tv_S_gamma': 14843.69,
12
    'tv_S_theta': 0.441,
13
    'search_S_alpha': 2.008,
14
    'search_S_gamma': 5915.51,
15
    'search_S_theta': 0.156,
16
    'ooh_S_alpha': 2.646,
17
    'ooh_S_gamma': 43217.94,
18
    'ooh_S_theta': 0.179
19
}
20
hyperparameters

{'facebook_S_alpha': 1.115, 'facebook_S_gamma': 2145.66, ... }

1
def adstock_transformation(x, decay):
2
    adstock = np.zeros(len(x))
3
    for t in range(len(x)):
4
        if t == 0:
5
            adstock[t] = x[t]
6
        else:
7
            adstock[t] = x[t] + decay * adstock[t-1]
8
    return adstock

1
def saturation_transformation(adstock_var, alpha, gamma):
2
    epsilon = 1e-6
3
    return 1/(1+(gamma/(adstock_var+epsilon))**alpha)

1
from sklearn.linear_model import LinearRegression
2
X = saturated
3
y = dt_simulated_weekly["revenue"]
4

5
model = LinearRegression()
6
model.fit(X, y)
7

8
print(f"Intercept: {model.intercept_}")
9
print(f"Coefficients: {model.coef_}")

Intercept: 672269.07
Coefficients: [879382.83 182146.33 152446.92 647846.63 796880.31]

1
np.max(model.coef_)

879382.83

1
import pyomo.environ as pyo
2
from pyomo.opt import SolverFactory
3

4
budget = {}
5
for m in media_var:
6
    budget[m] = [20000]
7
adstocked_spend = {}
8
for m in media_var:
9
    adstocked_spend[m] = adstock_transformation(budget[m], hyperparameters[m+'_theta'])
10
adstocked_spend = pd.DataFrame.from_dict(adstocked_spend)
11
adstocked_spend
12

13
saturated_spend = {}
14
for m in media_var:
15
    saturated_spend[m] = saturation_transformation(adstocked_spend[m], hyperparameters[m+'_alpha'],hyperparameters[m+'_gamma'])
16
saturated_spend = pd.DataFrame.from_dict(saturated_spend)
17
saturated_spend
18

19

20

21
# scikit-learn 회귀 모델에서 intercept_와 coef_를 가져옴
22
intercept_ = model.intercept_  # 회귀 모델의 절편
23
coef_ = model.coef_  # 회귀 모델의 계수
24

25
# Pyomo 모델 생성
26
model_pyomo = pyo.ConcreteModel()
27

28
# 광고 채널의 개수 (예: 5개 채널)
29
n_channels = len(X.columns)
30

31
# 변수 설정 (각 채널에 할당할 광고비)
32
model_pyomo.spend = pyo.Var(range(n_channels), domain=pyo.NonNegativeReals)
33

34
# 목적 함수 정의
35
def objective_function(model_pyomo):
36
    # Pyomo에서 회귀 모델 기반 목적 함수 정의
37
    return (model.intercept_ + sum(coef_[i] * model_pyomo.spend[i] for i in range(n_channels)))
38

39
model_pyomo.objective = pyo.Objective(rule=objective_function, sense=pyo.maximize)
40

41
# 제약 조건: 총 광고비는  sum(saturated_spend.iloc[0]) 을 넘지 않도록
42
def total_budget_constraint(model_pyomo):
43
    return sum(model_pyomo.spend[i] for i in range(n_channels)) <= sum(saturated_spend.iloc[0])
44

45
model_pyomo.budget_constraint = pyo.Constraint(rule=total_budget_constraint)
46

47
# # 제약 조건: TV 채널은 전체 예산의 50% 이하
48
def tv_constraint(model_pyomo):
49
    total_budget = sum(model_pyomo.spend[i] for i in range(n_channels))
50
    return model_pyomo.spend[0] <= 0.5 * total_budget
51

52
model_pyomo.tv_constraint = pyo.Constraint(rule=tv_constraint)
53

54
# Solver 설정 및 최적화 실행
55
opt = SolverFactory('glpk', executable='/usr/bin/glpsol')
56
result = opt.solve(model_pyomo)
57

58
# 최적화 결과 출력
59
optimal_spend = np.array([pyo.value(model_pyomo.spend[i]) for i in range(n_channels)])
60
actual_budget = sum(v[0] for v in budget.values())
61
print("Optimal spend allocation:")
62
df_alloc = pd.DataFrame({"Channel": ['tv_S', 'ooh_S', 'print_S', 'search_S', 'facebook_S'], "Spend": optimal_spend/(sum(optimal_spend))*actual_budget
63
})
64
display(df_alloc)