import pandas as pd

source_df = pd.read_csv("./data/Kevin_Hillstrom_MineThatData.csv")
source_df.tail()

mailed_df = source_df[source_df["segment"] != "No E-mail"].reset_index(drop=True)
mailed_df.tail()

mailed_df.dtypes

dummied_df = pd.get_dummies(mailed_df[["zip_code", "channel"]], drop_first=True)
#  필요없는 행을 지웁니다.
feature_vector_df = mailed_df.drop(
    [
        "history_segment",
        "zip_code",
        "channel",
        "segment",
        "visit",
        "conversion",
        "spend",
    ],
    axis=1,
)
feature_vector_df = feature_vector_df.join(dummied_df)
feature_vector_df.head()

is_treat_list = list(mailed_df["segment"] == "Mens E-Mail")
is_cv_list = list(mailed_df["visit"] == 1)

from sklearn.model_selection import train_test_split

(
    train_is_cv_list,
    test_is_cv_list,
    train_is_treat_list,
    test_is_treat_list,
    train_feature_vector_df,
    test_feature_vector_df,
) = train_test_split(
    is_cv_list, is_treat_list, feature_vector_df, test_size=0.5, random_state=42
)

from sklearn.linear_model import LogisticRegression

treat_model = LogisticRegression(C=0.01)
control_model = LogisticRegression(C=0.01)

train_sample_num = len(train_is_cv_list)

treat_is_cv_list = [
    train_is_cv_list[i]
    for i in range(train_sample_num)
    if train_is_treat_list[i] is True
]
treat_feature_vector_list = train_feature_vector_df[train_is_treat_list]

control_is_cv_list = [
    train_is_cv_list[i]
    for i in range(train_sample_num)
    if train_is_treat_list[i] is False
]
control_feature_vector_list = train_feature_vector_df[
    list(map(lambda a: a is False, train_is_treat_list))
]

treat_model.fit(treat_feature_vector_list, treat_is_cv_list)
control_model.fit(control_feature_vector_list, control_is_cv_list)

from operator import itemgetter

treat_score = treat_model.predict_proba(test_feature_vector_df)  # 실험군 예측값
control_score = control_model.predict_proba(test_feature_vector_df)  # 대조군 예측값
score_list = treat_score[:, 1] / control_score[:, 1]  # 업리프트 모델링 점수계산

result = list(zip(test_is_cv_list, test_is_treat_list, score_list))
result.sort(key=itemgetter(2), reverse=True)  # 점수가 높은 순으로 정렬

import matplotlib.pyplot as plt

%matplotlib inline

qdf = pd.DataFrame(columns=("treat_cvr", "control_cvr"))

quantile_data = []
for n in range(10):
    start = int(n * len(result) / 10)  # 결과를 10% 단위로 나눈다
    end = int((n + 1) * len(result) / 10) - 1
    quantiled_result = result[start:end]
    # 실험군과 대조군에서 결과 모으기
    treat_uu = list(map(lambda item: item[1], quantiled_result)).count(True)
    control_uu = list(map(lambda item: item[1], quantiled_result)).count(False)
    # 실험군과 대조군의 전환건수 세기
    treat_cv = [item[0] for item in quantiled_result if item[1] is True].count(True)
    control_cv = [item[0] for item in quantiled_result if item[1] is False].count(True)

    treat_cvr = treat_cv / treat_uu
    control_cvr = control_cv / control_uu

    quantile_data.append(
        [treat_uu, control_uu, treat_cv, control_cv, treat_cvr, control_cvr]
    )

    label = "{}%~{}%".format(n * 10, (n + 1) * 10)
    qdf.loc[label] = [treat_cvr, control_cvr]

qdf.plot.bar()
plt.xlabel("percentile")
plt.ylabel("conversion rate")

treat_uu = 0
control_uu = 0
treat_cv = 0
control_cv = 0
treat_cvr = 0.0
control_cvr = 0.0
lift = 0.0
stat_data = []

for is_cv, is_treat, score in result:
    if is_treat:
        treat_uu += 1
        if is_cv:
            treat_cv += 1
        treat_cvr = treat_cv / treat_uu
    else:
        control_uu += 1
        if is_cv:
            control_cv += 1
        control_cvr = control_cv / control_uu
    lift = (treat_cvr - control_cvr) * treat_uu
    stat_data.append(
        [
            is_cv,
            is_treat,
            score,
            treat_uu,
            control_uu,
            treat_cv,
            control_cv,
            treat_cvr,
            control_cvr,
            lift,
        ]
    )

df = pd.DataFrame(stat_data)
df.columns = [
    "is_cv",
    "is_treat",
    "score",
    "treat_uu",
    "control_uu",
    "treat_cv",
    "control_cv",
    "treat_cvr",
    "control_cvr",
    "lift",
]

df["base_line"] = df.index * df["lift"][len(df.index) - 1] / len(df.index)
f, ([ax0, ax1], [ax2, ax3]) = plt.subplots(
    nrows=2, ncols=2, sharex=True, figsize=(10, 8)
)

df.plot(y=["treat_cv", "control_cv"], ax=ax0)
ax0.set_xlabel("uplift score rank")
ax0.set_ylabel("conversion count")
df.plot(y=["treat_cvr", "control_cvr"], ylim=[0, 0.3], ax=ax1)
ax1.set_xlabel("uplift score rank")
ax1.set_ylabel("conversion rate")
df.plot(y=["lift", "base_line"], ax=ax2)
ax2.set_xlabel("uplift score rank")
ax2.set_ylabel("lift count")
ax3.axis("off")
plt.tight_layout()

f, ([ax0, ax1], [ax2, ax3]) = plt.subplots(
    nrows=2, ncols=2, sharex=True, figsize=(10, 8)
)
df.plot(y=["treat_cv", "control_cv"], x="score", title="conversion count", ax=ax0)
df.plot(
    y=["treat_cvr", "control_cvr"],
    ylim=[0, 0.3],
    x="score",
    title="conversion rate",
    ax=ax1,
)
df.plot(y=["lift", "base_line"], x="score", title="lift", ax=ax2)
ax3.axis("off")
plt.tight_layout()

import pandas as pd

df = (
    pd.read_csv("./data/Video_Games_Sales_as_at_22_Dec_2016.csv").dropna().reset_index()
)
df.tail()

X = df[["Critic_Score", "User_Score"]].astype("float32")
# X = [tuple(x) for x in subset.values]
# X = list(subset.itertuples(index=False))
sales = df["Global_Sales"].astype("float32")
# y= list(sales.iteritems())
# y = [tuple(x) for x in sales.values]
# print(X.shape, sales.shape)

%matplotlib inline

df[["Critic_Score", "User_Score", "Global_Sales"]].astype("float").plot.scatter(
    x="Critic_Score", y="Global_Sales", c="User_Score"
)

from sklearn.linear_model import LinearRegression

lm = LinearRegression(n_jobs=-1)
lm.fit(X, sales)
y_true = sales.values
y_pred = lm.predict(X)

import numpy as np


def MAE(y_true, y_pred):
    return np.mean(np.abs((y_true - y_pred)))


MAE(y_true, y_pred)

from sklearn.metrics import mean_absolute_error

mean_absolute_error(y_true, y_pred)

def MSE(y_true, y_pred):
    return np.mean(np.square((y_true - y_pred)))


MSE(y_true, y_pred)

from sklearn.metrics import mean_squared_error

mean_squared_error(y_true, y_pred)

np.sqrt(MSE(y_true, y_pred))

def MAPE(y_true, y_pred):
    return np.mean(np.abs((y_true - y_pred) / y_true)) * 100


MAPE(y_true, y_pred)

def MPE(y_true, y_pred):
    return np.mean((y_true - y_pred) / y_true) * 100


MPE(y_true, y_pred)